KILLED
proof of input_fFUjWy369C.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), 0 ms]
        (12) CpxTypedWeightedCompleteTrs
        (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (14) CpxRNTS
        (15) InliningProof [UPPER BOUND(ID), 877 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), 166 ms]
        (24) CpxRNTS
        (25) IntTrsBoundProof [UPPER BOUND(ID), 57 ms]
        (26) CpxRNTS
        (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (28) CpxRNTS
        (29) IntTrsBoundProof [UPPER BOUND(ID), 101 ms]
        (30) CpxRNTS
        (31) IntTrsBoundProof [UPPER BOUND(ID), 54 ms]
        (32) CpxRNTS
        (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (34) CpxRNTS
        (35) IntTrsBoundProof [UPPER BOUND(ID), 200 ms]
        (36) CpxRNTS
        (37) IntTrsBoundProof [UPPER BOUND(ID), 15 ms]
        (38) CpxRNTS
        (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (40) CpxRNTS
        (41) IntTrsBoundProof [UPPER BOUND(ID), 139 ms]
        (42) CpxRNTS
        (43) IntTrsBoundProof [UPPER BOUND(ID), 53 ms]
        (44) CpxRNTS
        (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (46) CpxRNTS
        (47) IntTrsBoundProof [UPPER BOUND(ID), 11.3 s]
        (48) CpxRNTS
        (49) IntTrsBoundProof [UPPER BOUND(ID), 2875 ms]
        (50) CpxRNTS
    (51) CompletionProof [UPPER BOUND(ID), 0 ms]
    (52) CpxTypedWeightedCompleteTrs
        (53) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (54) CpxRNTS
(55) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(56) CdtProblem
    (57) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (58) CdtProblem
    (59) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (64) CdtProblem
    (65) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 122 ms]
    (68) CdtProblem
    (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (80) CdtProblem
    (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 6 ms]
    (94) CdtProblem
    (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 311 ms]
    (98) CdtProblem
    (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 6 ms]
    (100) CdtProblem
    (101) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtRhsSimplificationProcessorProof [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) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (132) CdtProblem
    (133) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 1 ms]
    (138) CdtProblem
    (139) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (140) CdtProblem
    (141) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (144) CdtProblem
    (145) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 2 ms]
    (146) CdtProblem
    (147) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (156) CdtProblem
    (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (160) CdtProblem
    (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CdtProblem
    (163) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (166) CdtProblem
    (167) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (168) CdtProblem
    (169) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (172) CdtProblem
    (173) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 5 ms]
    (190) CdtProblem
    (191) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (194) CdtProblem
    (195) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (198) CdtProblem
    (199) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (202) CdtProblem
    (203) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) CdtProblem
    (205) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (210) CdtProblem
    (211) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 6 ms]
    (212) CdtProblem
    (213) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (214) CdtProblem
    (215) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (216) CdtProblem
    (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (218) CdtProblem
    (219) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (220) CdtProblem
    (221) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (222) CdtProblem
    (223) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 13 ms]
    (224) CdtProblem
    (225) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (226) CdtProblem
    (227) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (228) CdtProblem
    (229) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (230) CdtProblem
    (231) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (232) CdtProblem
    (233) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (234) CdtProblem
    (235) CdtNarrowingProof [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


----------------------------------------

(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, r)) -> false
   left(empty) -> empty
   left(node(l, r)) -> l
   right(empty) -> empty
   right(node(l, r)) -> r
   inc(0) -> s(0)
   inc(s(x)) -> s(inc(x))
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x))
   if(true, b, n, m, x, y) -> x
   if(false, false, n, m, x, y) -> count(m, x)
   if(false, true, n, m, x, y) -> count(n, y)
   nrOfNodes(n) -> count(n, 0)

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, r)) -> false
   left(empty) -> empty
   left(node(l, r)) -> l
   right(empty) -> empty
   right(node(l, r)) -> r
   inc(0') -> s(0')
   inc(s(x)) -> s(inc(x))
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x))
   if(true, b, n, m, x, y) -> x
   if(false, false, n, m, x, y) -> count(m, x)
   if(false, true, n, m, x, y) -> count(n, y)
   nrOfNodes(n) -> count(n, 0')

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, r)) -> false
   left(empty) -> empty
   left(node(l, r)) -> l
   right(empty) -> empty
   right(node(l, r)) -> r
   inc(0) -> s(0)
   inc(s(x)) -> s(inc(x))
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x))
   if(true, b, n, m, x, y) -> x
   if(false, false, n, m, x, y) -> count(m, x)
   if(false, true, n, m, x, y) -> count(n, y)
   nrOfNodes(n) -> count(n, 0)

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, r)) -> false [1]
   left(empty) -> empty [1]
   left(node(l, r)) -> l [1]
   right(empty) -> empty [1]
   right(node(l, r)) -> r [1]
   inc(0) -> s(0) [1]
   inc(s(x)) -> s(inc(x)) [1]
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x)) [1]
   if(true, b, n, m, x, y) -> x [1]
   if(false, false, n, m, x, y) -> count(m, x) [1]
   if(false, true, n, m, x, y) -> count(n, y) [1]
   nrOfNodes(n) -> count(n, 0) [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, r)) -> false [1]
   left(empty) -> empty [1]
   left(node(l, r)) -> l [1]
   right(empty) -> empty [1]
   right(node(l, r)) -> r [1]
   inc(0) -> s(0) [1]
   inc(s(x)) -> s(inc(x)) [1]
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x)) [1]
   if(true, b, n, m, x, y) -> x [1]
   if(false, false, n, m, x, y) -> count(m, x) [1]
   if(false, true, n, m, x, y) -> count(n, y) [1]
   nrOfNodes(n) -> count(n, 0) [1]

The TRS has the following type information:
isEmpty :: empty:node -> true:false
empty :: empty:node
true :: true:false
node :: empty:node -> empty:node -> empty:node
false :: true:false
left :: empty:node -> empty:node
right :: empty:node -> empty:node
inc :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
count :: empty:node -> 0:s -> 0:s
if :: true:false -> true:false -> empty:node -> empty:node -> 0:s -> 0:s -> 0:s
nrOfNodes :: empty:node -> 0:s

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:

   count_2
   if_6
   nrOfNodes_1

(c) The following functions are completely defined:

   isEmpty_1
   left_1
   right_1
   inc_1

Due to the following rules being added:
none

And the following fresh constants: none

----------------------------------------

(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, r)) -> false [1]
   left(empty) -> empty [1]
   left(node(l, r)) -> l [1]
   right(empty) -> empty [1]
   right(node(l, r)) -> r [1]
   inc(0) -> s(0) [1]
   inc(s(x)) -> s(inc(x)) [1]
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x)) [1]
   if(true, b, n, m, x, y) -> x [1]
   if(false, false, n, m, x, y) -> count(m, x) [1]
   if(false, true, n, m, x, y) -> count(n, y) [1]
   nrOfNodes(n) -> count(n, 0) [1]

The TRS has the following type information:
isEmpty :: empty:node -> true:false
empty :: empty:node
true :: true:false
node :: empty:node -> empty:node -> empty:node
false :: true:false
left :: empty:node -> empty:node
right :: empty:node -> empty:node
inc :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
count :: empty:node -> 0:s -> 0:s
if :: true:false -> true:false -> empty:node -> empty:node -> 0:s -> 0:s -> 0:s
nrOfNodes :: empty:node -> 0:s

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, r)) -> false [1]
   left(empty) -> empty [1]
   left(node(l, r)) -> l [1]
   right(empty) -> empty [1]
   right(node(l, r)) -> r [1]
   inc(0) -> s(0) [1]
   inc(s(x)) -> s(inc(x)) [1]
   count(empty, 0) -> if(true, isEmpty(empty), empty, node(left(empty), node(right(empty), empty)), 0, s(0)) [8]
   count(empty, s(x')) -> if(true, isEmpty(empty), empty, node(left(empty), node(right(empty), empty)), s(x'), s(inc(x'))) [8]
   count(node(l', r'), 0) -> if(false, isEmpty(l'), r', node(left(l'), node(right(l'), r')), 0, s(0)) [8]
   count(node(l', r'), s(x'')) -> if(false, isEmpty(l'), r', node(left(l'), node(right(l'), r')), s(x''), s(inc(x''))) [8]
   if(true, b, n, m, x, y) -> x [1]
   if(false, false, n, m, x, y) -> count(m, x) [1]
   if(false, true, n, m, x, y) -> count(n, y) [1]
   nrOfNodes(n) -> count(n, 0) [1]

The TRS has the following type information:
isEmpty :: empty:node -> true:false
empty :: empty:node
true :: true:false
node :: empty:node -> empty:node -> empty:node
false :: true:false
left :: empty:node -> empty:node
right :: empty:node -> empty:node
inc :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
count :: empty:node -> 0:s -> 0:s
if :: true:false -> true:false -> empty:node -> empty:node -> 0:s -> 0:s -> 0:s
nrOfNodes :: empty:node -> 0:s

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 => 1
   false => 0
   0 => 0

----------------------------------------

(14)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 8 }-> if(1, isEmpty(0), 0, 1 + left(0) + (1 + right(0) + 0), 0, 1 + 0) :|: z = 0, z' = 0
   count(z, z') -{ 8 }-> if(1, isEmpty(0), 0, 1 + left(0) + (1 + right(0) + 0), 1 + x', 1 + inc(x')) :|: z' = 1 + x', x' >= 0, z = 0
   count(z, z') -{ 8 }-> if(0, isEmpty(l'), r', 1 + left(l') + (1 + right(l') + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0
   count(z, z') -{ 8 }-> if(0, isEmpty(l'), r', 1 + left(l') + (1 + right(l') + r'), 1 + x'', 1 + inc(x'')) :|: z = 1 + l' + r', z' = 1 + x'', l' >= 0, r' >= 0, x'' >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> x :|: b >= 0, n >= 0, z2 = x, z'' = n, z = 1, z1 = m, z3 = y, x >= 0, y >= 0, z' = b, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(m, x) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z = 0, z' = 0, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(n, y) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z' = 1, z = 0, m >= 0
   inc(z) -{ 1 }-> 1 + inc(x) :|: x >= 0, z = 1 + x
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(n, 0) :|: n >= 0, z = n
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0


----------------------------------------

(15) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   right(z) -{ 1 }-> 0 :|: z = 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0

----------------------------------------

(16)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + x', 1 + inc(x')) :|: z' = 1 + x', x' >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + x'', 1 + inc(x'')) :|: z = 1 + l' + r', z' = 1 + x'', l' >= 0, r' >= 0, x'' >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + x'', 1 + inc(x'')) :|: z = 1 + l' + r', z' = 1 + x'', l' >= 0, r' >= 0, x'' >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> x :|: b >= 0, n >= 0, z2 = x, z'' = n, z = 1, z1 = m, z3 = y, x >= 0, y >= 0, z' = b, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(m, x) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z = 0, z' = 0, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(n, y) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z' = 1, z = 0, m >= 0
   inc(z) -{ 1 }-> 1 + inc(x) :|: x >= 0, z = 1 + x
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(n, 0) :|: n >= 0, z = n
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0


----------------------------------------

(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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0


----------------------------------------

(19) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { isEmpty }
   { right }
   { inc }
   { left }
   { count, if }
   { nrOfNodes }

----------------------------------------

(20)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {isEmpty}, {right}, {inc}, {left}, {count,if}, {nrOfNodes}

----------------------------------------

(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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {isEmpty}, {right}, {inc}, {left}, {count,if}, {nrOfNodes}

----------------------------------------

(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: 1

----------------------------------------

(24)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {isEmpty}, {right}, {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: ?, size: O(1) [1]

----------------------------------------

(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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {right}, {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]

----------------------------------------

(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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {right}, {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]

----------------------------------------

(29) 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

----------------------------------------

(30)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {right}, {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: ?, size: O(n^1) [z]

----------------------------------------

(31) 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

----------------------------------------

(32)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: 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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]

----------------------------------------

(35) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: inc
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 1 + z

----------------------------------------

(36)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {inc}, {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: ?, size: O(n^1) [1 + z]

----------------------------------------

(37) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: inc
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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + inc(z' - 1)) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 }-> 1 + inc(z - 1) :|: z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + 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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]

----------------------------------------

(41) 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

----------------------------------------

(42)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {left}, {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]
  left: runtime: ?, size: O(n^1) [z]

----------------------------------------

(43) 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

----------------------------------------

(44)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]
  left: 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:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]
  left: runtime: O(1) [1], size: O(n^1) [z]

----------------------------------------

(47) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: count
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: ?

----------------------------------------

(48)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]
  left: runtime: O(1) [1], size: O(n^1) [z]
  count: runtime: ?, size: INF
  if: runtime: ?, size: INF

----------------------------------------

(49) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: count
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

----------------------------------------

(50)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 11 }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 0, 1 + 0) :|: z = 0, z' = 0, 0 = 0
   count(z, z') -{ 11 + z' }-> if(1, 1, 0, 1 + 0 + (1 + 0 + 0), 1 + (z' - 1), 1 + s') :|: s' >= 0, s' <= z' - 1 + 1, z' - 1 >= 0, z = 0, 0 = 0
   count(z, z') -{ 11 }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, l' = 0
   count(z, z') -{ 11 + z' }-> if(0, 1, r', 1 + 0 + (1 + 0 + r'), 1 + (z' - 1), 1 + s'') :|: s'' >= 0, s'' <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, l' = 0
   count(z, z') -{ 11 }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 0, 1 + 0) :|: z = 1 + l' + r', l' >= 0, r' >= 0, z' = 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   count(z, z') -{ 11 + z' }-> if(0, 0, r', 1 + l'' + (1 + r1 + r'), 1 + (z' - 1), 1 + s1) :|: s1 >= 0, s1 <= z' - 1 + 1, z = 1 + l' + r', l' >= 0, r' >= 0, z' - 1 >= 0, r >= 0, l' = 1 + l + r, l >= 0, r'' >= 0, l' = 1 + l'' + r'', l'' >= 0, r1 >= 0, l' = 1 + l1 + r1, l1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z' >= 0, z'' >= 0, z = 1, z2 >= 0, z3 >= 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z'', z3) :|: z'' >= 0, z2 >= 0, z3 >= 0, z' = 1, z = 0, z1 >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(z1, z2) :|: z'' >= 0, z2 >= 0, z3 >= 0, z = 0, z' = 0, z1 >= 0
   inc(z) -{ 1 + z }-> 1 + s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(z, 0) :|: z >= 0
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {count,if}, {nrOfNodes}
Previous analysis results are:
  isEmpty: runtime: O(1) [1], size: O(1) [1]
  right: runtime: O(1) [1], size: O(n^1) [z]
  inc: runtime: O(n^1) [1 + z], size: O(n^1) [1 + z]
  left: runtime: O(1) [1], size: O(n^1) [z]
  count: runtime: INF, size: INF
  if: runtime: ?, size: INF

----------------------------------------

(51) 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:
none

And the following fresh constants: none

----------------------------------------

(52)
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, r)) -> false [1]
   left(empty) -> empty [1]
   left(node(l, r)) -> l [1]
   right(empty) -> empty [1]
   right(node(l, r)) -> r [1]
   inc(0) -> s(0) [1]
   inc(s(x)) -> s(inc(x)) [1]
   count(n, x) -> if(isEmpty(n), isEmpty(left(n)), right(n), node(left(left(n)), node(right(left(n)), right(n))), x, inc(x)) [1]
   if(true, b, n, m, x, y) -> x [1]
   if(false, false, n, m, x, y) -> count(m, x) [1]
   if(false, true, n, m, x, y) -> count(n, y) [1]
   nrOfNodes(n) -> count(n, 0) [1]

The TRS has the following type information:
isEmpty :: empty:node -> true:false
empty :: empty:node
true :: true:false
node :: empty:node -> empty:node -> empty:node
false :: true:false
left :: empty:node -> empty:node
right :: empty:node -> empty:node
inc :: 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
count :: empty:node -> 0:s -> 0:s
if :: true:false -> true:false -> empty:node -> empty:node -> 0:s -> 0:s -> 0:s
nrOfNodes :: empty:node -> 0:s

Rewrite Strategy: INNERMOST
----------------------------------------

(53) 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 => 1
   false => 0
   0 => 0

----------------------------------------

(54)
Obligation:
Complexity RNTS consisting of the following rules:

   count(z, z') -{ 1 }-> if(isEmpty(n), isEmpty(left(n)), right(n), 1 + left(left(n)) + (1 + right(left(n)) + right(n)), x, inc(x)) :|: n >= 0, z' = x, z = n, x >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> x :|: b >= 0, n >= 0, z2 = x, z'' = n, z = 1, z1 = m, z3 = y, x >= 0, y >= 0, z' = b, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(m, x) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z = 0, z' = 0, m >= 0
   if(z, z', z'', z1, z2, z3) -{ 1 }-> count(n, y) :|: n >= 0, z2 = x, z'' = n, z1 = m, z3 = y, x >= 0, y >= 0, z' = 1, z = 0, m >= 0
   inc(z) -{ 1 }-> 1 + inc(x) :|: x >= 0, z = 1 + x
   inc(z) -{ 1 }-> 1 + 0 :|: z = 0
   isEmpty(z) -{ 1 }-> 1 :|: z = 0
   isEmpty(z) -{ 1 }-> 0 :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> l :|: r >= 0, z = 1 + l + r, l >= 0
   left(z) -{ 1 }-> 0 :|: z = 0
   nrOfNodes(z) -{ 1 }-> count(n, 0) :|: n >= 0, z = n
   right(z) -{ 1 }-> r :|: r >= 0, z = 1 + l + r, l >= 0
   right(z) -{ 1 }-> 0 :|: z = 0

Only complete derivations are relevant for the runtime complexity.

----------------------------------------

(55) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
   count(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))
   if(true, z0, z1, z2, z3, z4) -> z3
   if(false, false, z0, z1, z2, z3) -> count(z1, z2)
   if(false, true, z0, z1, z2, z3) -> count(z0, z3)
   nrOfNodes(z0) -> count(z0, 0)
Tuples:
   ISEMPTY(empty) -> c
   ISEMPTY(node(z0, z1)) -> c1
   LEFT(empty) -> c2
   LEFT(node(z0, z1)) -> c3
   RIGHT(empty) -> c4
   RIGHT(node(z0, z1)) -> c5
   INC(0) -> c6
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(z0))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), LEFT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(true, z0, z1, z2, z3, z4) -> c15
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   NROFNODES(z0) -> c18(COUNT(z0, 0))
S tuples:
   ISEMPTY(empty) -> c
   ISEMPTY(node(z0, z1)) -> c1
   LEFT(empty) -> c2
   LEFT(node(z0, z1)) -> c3
   RIGHT(empty) -> c4
   RIGHT(node(z0, z1)) -> c5
   INC(0) -> c6
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(z0))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), LEFT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(true, z0, z1, z2, z3, z4) -> c15
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   NROFNODES(z0) -> c18(COUNT(z0, 0))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1, count_2, if_6, nrOfNodes_1

Defined Pair Symbols:   ISEMPTY_1, LEFT_1, RIGHT_1, INC_1, COUNT_2, IF_6, NROFNODES_1

Compound Symbols:   c, c1, c2, c3, c4, c5, c6, c7_1, c8_2, c9_3, c10_2, c11_3, c12_3, c13_2, c14_2, c15, c16_1, c17_1, c18_1


----------------------------------------

(57) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   NROFNODES(z0) -> c18(COUNT(z0, 0))
Removed 8 trailing nodes:
   INC(0) -> c6
   RIGHT(node(z0, z1)) -> c5
   LEFT(node(z0, z1)) -> c3
   IF(true, z0, z1, z2, z3, z4) -> c15
   LEFT(empty) -> c2
   ISEMPTY(node(z0, z1)) -> c1
   RIGHT(empty) -> c4
   ISEMPTY(empty) -> c

----------------------------------------

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
   count(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))
   if(true, z0, z1, z2, z3, z4) -> z3
   if(false, false, z0, z1, z2, z3) -> count(z1, z2)
   if(false, true, z0, z1, z2, z3) -> count(z0, z3)
   nrOfNodes(z0) -> count(z0, 0)
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(z0))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), LEFT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(z0))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), ISEMPTY(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), LEFT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(left(z0)), LEFT(z0))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), RIGHT(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1, count_2, if_6, nrOfNodes_1

Defined Pair Symbols:   INC_1, COUNT_2, IF_6

Compound Symbols:   c7_1, c8_2, c9_3, c10_2, c11_3, c12_3, c13_2, c14_2, c16_1, c17_1


----------------------------------------

(59) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing tuple parts
----------------------------------------

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
   count(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))
   if(true, z0, z1, z2, z3, z4) -> z3
   if(false, false, z0, z1, z2, z3) -> count(z1, z2)
   if(false, true, z0, z1, z2, z3) -> count(z0, z3)
   nrOfNodes(z0) -> count(z0, 0)
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1, count_2, if_6, nrOfNodes_1

Defined Pair Symbols:   INC_1, COUNT_2, IF_6

Compound Symbols:   c7_1, c14_2, c16_1, c17_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(61) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   count(z0, z1) -> if(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))
   if(true, z0, z1, z2, z3, z4) -> z3
   if(false, false, z0, z1, z2, z3) -> count(z1, z2)
   if(false, true, z0, z1, z2, z3) -> count(z0, z3)
   nrOfNodes(z0) -> count(z0, 0)

----------------------------------------

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, COUNT_2, IF_6

Compound Symbols:   c7_1, c14_2, c16_1, c17_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(63) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c14(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)), INC(z1)) by 
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)), INC(0))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))

----------------------------------------

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)), INC(0))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)), INC(0))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
K tuples:none
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1


----------------------------------------

(67) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   COUNT(empty, x1) -> c14(INC(x1))
We considered the (Usable) Rules:none
And the Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(COUNT(x_1, x_2)) = [1]
   POL(IF(x_1, x_2, x_3, x_4, x_5, x_6)) = [1]
   POL(INC(x_1)) = 0
   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(c14(x_1, x_2)) = x_1 + x_2
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(empty) = 0
   POL(false) = [1]
   POL(inc(x_1)) = 0
   POL(isEmpty(x_1)) = [1]
   POL(left(x_1)) = [1]
   POL(node(x_1, x_2)) = 0
   POL(right(x_1)) = [1]
   POL(s(x_1)) = 0
   POL(true) = [1]

----------------------------------------

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1


----------------------------------------

(69) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c8(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1


----------------------------------------

(71) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1


----------------------------------------

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c9(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1


----------------------------------------

(75) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c10_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1


----------------------------------------

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c10(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1


----------------------------------------

(79) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c11_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1


----------------------------------------

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c11(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1


----------------------------------------

(83) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c11(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c12_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1


----------------------------------------

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c12(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1


----------------------------------------

(87) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c12(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1)))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c13_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1


----------------------------------------

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(z0, z1) -> c13(IF(isEmpty(z0), isEmpty(left(z0)), right(z0), node(left(left(z0)), node(right(left(z0)), right(z0))), z1, inc(z1))) by 
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))

----------------------------------------

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(91) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x1) -> c13(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))

----------------------------------------

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, s(z0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))), INC(s(z0))) by 
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))

----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(95) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(97) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
We considered the (Usable) Rules:none
And the Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(COUNT(x_1, x_2)) = [1]
   POL(IF(x_1, x_2, x_3, x_4, x_5, x_6)) = [1]
   POL(INC(x_1)) = 0
   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(c14(x_1, x_2)) = x_1 + x_2
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(empty) = 0
   POL(false) = [1]
   POL(inc(x_1)) = [1] + x_1
   POL(isEmpty(x_1)) = [1]
   POL(left(x_1)) = [1]
   POL(node(x_1, x_2)) = 0
   POL(right(x_1)) = [1]
   POL(s(x_1)) = 0
   POL(true) = [1]

----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(99) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)), INC(x1)) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)), INC(0))
   COUNT(empty, s(z0)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))

----------------------------------------

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(101) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(empty, x0) -> c14(INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(103) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x0) -> c14(INC(x0))

----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(105) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))

----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)), INC(0))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)), INC(0))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(107) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(109) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)), INC(x1)) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, s(z0)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))

----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(111) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(empty, x0) -> c14(INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(113) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))

----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(115) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))

----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(117) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1)) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, s(z0)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))

----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(121) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, x0) -> c14(INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(123) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))

----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(125) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))

----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(127) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(129) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1)) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, s(z0)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))

----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(131) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, x0) -> c14(INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(133) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))

----------------------------------------

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(135) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))

----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(137) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(139) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)), INC(x1)) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, s(z0)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))

----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)), INC(0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(141) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, x0) -> c14(INC(x0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(143) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))
   COUNT(empty, x0) -> c14(INC(x0))

----------------------------------------

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))

----------------------------------------

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(147) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_2, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1


----------------------------------------

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)), INC(x1)) by 
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
   COUNT(node(x0, x1), s(z0)) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))), INC(s(z0)))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))

----------------------------------------

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)), INC(0))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(151) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, 0) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0))) by 
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))

----------------------------------------

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(155) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, 0) -> c14(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))

----------------------------------------

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, 0) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))

----------------------------------------

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(159) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, 0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))

----------------------------------------

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, s(z0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0)))) by 
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))

----------------------------------------

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(163) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, s(x1)) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))

----------------------------------------

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(165) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(empty, s(z0)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))

----------------------------------------

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(167) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))

----------------------------------------

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(169) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))

----------------------------------------

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(171) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))

----------------------------------------

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(173) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))

----------------------------------------

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(175) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(177) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(179) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(181) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(183) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(185) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c8(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(187) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(189) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(191) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c8(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(193) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c8_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2


----------------------------------------

(195) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c8(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c8(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(197) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, 0) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))

----------------------------------------

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(199) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, 0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))

----------------------------------------

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(201) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, s(z0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0)))) by 
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))

----------------------------------------

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(203) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, s(x1)) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))

----------------------------------------

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(205) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(empty, s(z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))

----------------------------------------

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(207) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))

----------------------------------------

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(209) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))

----------------------------------------

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(211) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))

----------------------------------------

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(213) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))

----------------------------------------

(214)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(215) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(216)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(217) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(218)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(219) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(220)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(221) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(222)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(223) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(224)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(225) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c9(IF(true, isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(226)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(227) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(228)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(229) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(empty, x1) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1))) by 
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(empty, s(z0)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(z0), s(inc(z0))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(230)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(231) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, x0) -> c9(IF(true, isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))

----------------------------------------

(232)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(233) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(234)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c9_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1


----------------------------------------

(235) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(node(z0, z1), x1) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1))) by 
   COUNT(node(x0, x1), 0) -> c9(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), s(z0)) -> c9(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), s(z0), s(inc(z0))))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))

----------------------------------------

(236)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1, c9_1


----------------------------------------

(237) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace COUNT(x0, 0) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0))) by 
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))

----------------------------------------

(238)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1, c9_1


----------------------------------------

(239) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   COUNT(empty, 0) -> c10(IF(true, isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))

----------------------------------------

(240)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   isEmpty(empty) -> true
   isEmpty(node(z0, z1)) -> false
   left(empty) -> empty
   left(node(z0, z1)) -> z0
   right(empty) -> empty
   right(node(z0, z1)) -> z1
   inc(0) -> s(0)
   inc(s(z0)) -> s(inc(z0))
Tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
S tuples:
   INC(s(z0)) -> c7(INC(z0))
   IF(false, false, z0, z1, z2, z3) -> c16(COUNT(z1, z2))
   IF(false, true, z0, z1, z2, z3) -> c17(COUNT(z0, z3))
   COUNT(x0, s(z0)) -> c10(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c11(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c11(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c11(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c12(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c12(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c12(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, 0) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), 0, s(0)))
   COUNT(x0, s(z0)) -> c13(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(z0), s(inc(z0))))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(empty, x1) -> c13(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(node(z0, z1), x1) -> c13(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x1, inc(x1)))
   COUNT(x0, s(0)) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))), INC(s(0)))
   COUNT(x0, s(s(z0))) -> c14(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))), INC(s(s(z0))))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(node(z0, z1), s(x1)) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))), INC(s(x1)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), x1)), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(x0), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(x0), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), x2) -> c14(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(left(node(x0, x1))), x1, node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, x0) -> c14(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)), INC(x0))
   COUNT(empty, 0) -> c14(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(node(z0, z1), x1), x2) -> c14(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(empty, x1), x2) -> c14(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)), INC(x2))
   COUNT(node(z0, z1), x2) -> c14(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)), INC(x2))
   COUNT(node(x0, x1), 0) -> c14(IF(isEmpty(node(x0, x1)), isEmpty(x0), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(node(x0, x1), 0) -> c14(IF(false, isEmpty(left(node(x0, x1))), right(node(x0, x1)), node(left(left(node(x0, x1))), node(right(left(node(x0, x1))), right(node(x0, x1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c8(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c8(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c8(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c8(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c8(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c8(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(x0, s(0)) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(0), s(s(0))))
   COUNT(x0, s(s(z0))) -> c9(IF(isEmpty(x0), isEmpty(left(x0)), right(x0), node(left(left(x0)), node(right(left(x0)), right(x0))), s(s(z0)), s(s(inc(z0)))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, s(x1)) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(node(z0, z1), s(x1)) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), s(x1), s(inc(x1))))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(empty, right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(empty), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(z1, right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(left(left(node(empty, x1))), node(empty, right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(empty, node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(empty), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), isEmpty(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)), node(z0, node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), isEmpty(left(node(empty, x1))), right(node(empty, x1)), node(empty, node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), isEmpty(empty), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(z0, z1), x2) -> c9(IF(isEmpty(node(z0, z1)), isEmpty(z0), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, x0) -> c9(IF(isEmpty(empty), true, right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), x0, inc(x0)))
   COUNT(node(node(z0, z1), x1), x2) -> c9(IF(isEmpty(node(node(z0, z1), x1)), false, right(node(node(z0, z1), x1)), node(left(left(node(node(z0, z1), x1))), node(right(left(node(node(z0, z1), x1))), right(node(node(z0, z1), x1)))), x2, inc(x2)))
   COUNT(node(empty, x1), x2) -> c9(IF(isEmpty(node(empty, x1)), true, right(node(empty, x1)), node(left(left(node(empty, x1))), node(right(left(node(empty, x1))), right(node(empty, x1)))), x2, inc(x2)))
   COUNT(node(z0, z1), x2) -> c9(IF(false, isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), x2, inc(x2)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(left(empty)), empty)), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), z1)), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(left(empty)), node(right(empty), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(z0), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), right(empty), node(left(empty), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(z0), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(left(empty)), empty, node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(left(node(z0, z1))), z1, node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(empty, 0) -> c10(IF(isEmpty(empty), isEmpty(empty), right(empty), node(left(left(empty)), node(right(left(empty)), right(empty))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(isEmpty(node(z0, z1)), isEmpty(z0), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
   COUNT(node(z0, z1), 0) -> c10(IF(false, isEmpty(left(node(z0, z1))), right(node(z0, z1)), node(left(left(node(z0, z1))), node(right(left(node(z0, z1))), right(node(z0, z1)))), 0, s(0)))
K tuples:
   COUNT(empty, x1) -> c14(INC(x1))
   COUNT(x0, s(x1)) -> c14(INC(s(x1)))
   COUNT(empty, s(x1)) -> c14(INC(s(x1)))
Defined Rule Symbols:   isEmpty_1, left_1, right_1, inc_1

Defined Pair Symbols:   INC_1, IF_6, COUNT_2

Compound Symbols:   c7_1, c16_1, c17_1, c14_1, c10_1, c11_1, c12_1, c13_1, c14_2, c8_1, c9_1