KILLED
proof of input_t2V0b8CwOM.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) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (16) CpxRNTS
    (17) CompletionProof [UPPER BOUND(ID), 0 ms]
    (18) CpxTypedWeightedCompleteTrs
        (19) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (20) CpxRNTS
(21) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(22) CdtProblem
    (23) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (24) CdtProblem
    (25) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (26) CdtProblem
    (27) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 4 ms]
    (28) CdtProblem
    (29) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CdtProblem
    (31) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CdtProblem
    (33) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (34) CdtProblem
    (35) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (36) CdtProblem
    (37) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (38) CdtProblem
    (39) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CdtProblem
    (41) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (42) CdtProblem
    (43) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (44) CdtProblem
    (45) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (46) CdtProblem
    (47) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (48) CdtProblem
    (49) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (50) CdtProblem
    (51) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
    (53) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (54) CdtProblem
    (55) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (56) CdtProblem
    (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (58) CdtProblem
    (59) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 3 ms]
    (64) CdtProblem
    (65) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (68) CdtProblem
    (69) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 106 ms]
    (80) CdtProblem
    (81) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 125 ms]
    (88) CdtProblem
    (89) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 105 ms]
    (90) CdtProblem
    (91) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 124 ms]
    (102) 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:

   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(t, 0) -> t
   foldB(t, s(n)) -> f(foldB(t, n), B)
   foldC(t, 0) -> t
   foldC(t, s(n)) -> f(foldC(t, n), C)
   f(t, x) -> f'(t, g(x))
   f'(triple(a, b, c), C) -> triple(a, b, s(c))
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A)
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b))
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c)

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:

   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(t, 0') -> t
   foldB(t, s(n)) -> f(foldB(t, n), B)
   foldC(t, 0') -> t
   foldC(t, s(n)) -> f(foldC(t, n), C)
   f(t, x) -> f'(t, g(x))
   f'(triple(a, b, c), C) -> triple(a, b, s(c))
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A)
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0', c), b))
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0'), c)

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:

   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(t, 0) -> t
   foldB(t, s(n)) -> f(foldB(t, n), B)
   foldC(t, 0) -> t
   foldC(t, s(n)) -> f(foldC(t, n), C)
   f(t, x) -> f'(t, g(x))
   f'(triple(a, b, c), C) -> triple(a, b, s(c))
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A)
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b))
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c)

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:

   g(A) -> A [1]
   g(B) -> A [1]
   g(B) -> B [1]
   g(C) -> A [1]
   g(C) -> B [1]
   g(C) -> C [1]
   foldB(t, 0) -> t [1]
   foldB(t, s(n)) -> f(foldB(t, n), B) [1]
   foldC(t, 0) -> t [1]
   foldC(t, s(n)) -> f(foldC(t, n), C) [1]
   f(t, x) -> f'(t, g(x)) [1]
   f'(triple(a, b, c), C) -> triple(a, b, s(c)) [1]
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A) [1]
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b)) [1]
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c) [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:

   g(A) -> A [1]
   g(B) -> A [1]
   g(B) -> B [1]
   g(C) -> A [1]
   g(C) -> B [1]
   g(C) -> C [1]
   foldB(t, 0) -> t [1]
   foldB(t, s(n)) -> f(foldB(t, n), B) [1]
   foldC(t, 0) -> t [1]
   foldC(t, s(n)) -> f(foldC(t, n), C) [1]
   f(t, x) -> f'(t, g(x)) [1]
   f'(triple(a, b, c), C) -> triple(a, b, s(c)) [1]
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A) [1]
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b)) [1]
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c) [1]

The TRS has the following type information:
g :: A:B:C -> A:B:C
A :: A:B:C
B :: A:B:C
C :: A:B:C
foldB :: triple -> 0:s -> triple
0 :: 0:s
s :: 0:s -> 0:s
f :: triple -> A:B:C -> triple
foldC :: triple -> 0:s -> triple
f' :: triple -> A:B:C -> triple
triple :: 0:s -> 0:s -> 0:s -> triple
f'' :: triple -> triple

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

(c) The following functions are completely defined:

   g_1
   foldC_2
   foldB_2
   f_2
   f'_2
   f''_1

Due to the following rules being added:

   f'(v0, v1) -> const [0]
   f''(v0) -> const [0]

And the following fresh constants:    const

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

(10)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   g(A) -> A [1]
   g(B) -> A [1]
   g(B) -> B [1]
   g(C) -> A [1]
   g(C) -> B [1]
   g(C) -> C [1]
   foldB(t, 0) -> t [1]
   foldB(t, s(n)) -> f(foldB(t, n), B) [1]
   foldC(t, 0) -> t [1]
   foldC(t, s(n)) -> f(foldC(t, n), C) [1]
   f(t, x) -> f'(t, g(x)) [1]
   f'(triple(a, b, c), C) -> triple(a, b, s(c)) [1]
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A) [1]
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b)) [1]
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c) [1]
   f'(v0, v1) -> const [0]
   f''(v0) -> const [0]

The TRS has the following type information:
g :: A:B:C -> A:B:C
A :: A:B:C
B :: A:B:C
C :: A:B:C
foldB :: triple:const -> 0:s -> triple:const
0 :: 0:s
s :: 0:s -> 0:s
f :: triple:const -> A:B:C -> triple:const
foldC :: triple:const -> 0:s -> triple:const
f' :: triple:const -> A:B:C -> triple:const
triple :: 0:s -> 0:s -> 0:s -> triple:const
f'' :: triple:const -> triple:const
const :: triple:const

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

(11) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(12)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   g(A) -> A [1]
   g(B) -> A [1]
   g(B) -> B [1]
   g(C) -> A [1]
   g(C) -> B [1]
   g(C) -> C [1]
   foldB(t, 0) -> t [1]
   foldB(t, s(0)) -> f(t, B) [2]
   foldB(t, s(s(n'))) -> f(f(foldB(t, n'), B), B) [2]
   foldC(t, 0) -> t [1]
   foldC(t, s(0)) -> f(t, C) [2]
   foldC(t, s(s(n''))) -> f(f(foldC(t, n''), C), C) [2]
   f(t, A) -> f'(t, A) [2]
   f(t, B) -> f'(t, A) [2]
   f(t, B) -> f'(t, B) [2]
   f(t, C) -> f'(t, A) [2]
   f(t, C) -> f'(t, B) [2]
   f(t, C) -> f'(t, C) [2]
   f'(triple(a, b, c), C) -> triple(a, b, s(c)) [1]
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A) [1]
   f'(triple(a, 0, c), A) -> f''(triple(s(a), 0, c)) [2]
   f'(triple(a, s(n1), c), A) -> f''(f(foldB(triple(s(a), 0, c), n1), B)) [2]
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c) [1]
   f'(v0, v1) -> const [0]
   f''(v0) -> const [0]

The TRS has the following type information:
g :: A:B:C -> A:B:C
A :: A:B:C
B :: A:B:C
C :: A:B:C
foldB :: triple:const -> 0:s -> triple:const
0 :: 0:s
s :: 0:s -> 0:s
f :: triple:const -> A:B:C -> triple:const
foldC :: triple:const -> 0:s -> triple:const
f' :: triple:const -> A:B:C -> triple:const
triple :: 0:s -> 0:s -> 0:s -> triple:const
f'' :: triple:const -> triple:const
const :: triple:const

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

(13) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   A => 0
   B => 1
   C => 2
   0 => 0
   const => 0

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

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

   f(z, z') -{ 2 }-> f'(t, 2) :|: z' = 2, z = t, t >= 0
   f(z, z') -{ 2 }-> f'(t, 1) :|: z = t, t >= 0, z' = 1
   f(z, z') -{ 2 }-> f'(t, 1) :|: z' = 2, z = t, t >= 0
   f(z, z') -{ 2 }-> f'(t, 0) :|: z = t, t >= 0, z' = 0
   f(z, z') -{ 2 }-> f'(t, 0) :|: z = t, t >= 0, z' = 1
   f(z, z') -{ 2 }-> f'(t, 0) :|: z' = 2, z = t, t >= 0
   f'(z, z') -{ 2 }-> f''(f(foldB(1 + (1 + a) + 0 + c, n1), 1)) :|: z = 1 + a + (1 + n1) + c, a >= 0, c >= 0, n1 >= 0, z' = 0
   f'(z, z') -{ 2 }-> f''(1 + (1 + a) + 0 + c) :|: a >= 0, c >= 0, z = 1 + a + 0 + c, z' = 0
   f'(z, z') -{ 1 }-> f(1 + a + b + c, 0) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c, z' = 1
   f'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   f'(z, z') -{ 1 }-> 1 + a + b + (1 + c) :|: b >= 0, z' = 2, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 1 }-> foldC(1 + a + b + 0, c) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   foldB(z, z') -{ 1 }-> t :|: z = t, t >= 0, z' = 0
   foldB(z, z') -{ 2 }-> f(t, 1) :|: z = t, t >= 0, z' = 1 + 0
   foldB(z, z') -{ 2 }-> f(f(foldB(t, n'), 1), 1) :|: z = t, z' = 1 + (1 + n'), n' >= 0, t >= 0
   foldC(z, z') -{ 1 }-> t :|: z = t, t >= 0, z' = 0
   foldC(z, z') -{ 2 }-> f(t, 2) :|: z = t, t >= 0, z' = 1 + 0
   foldC(z, z') -{ 2 }-> f(f(foldC(t, n''), 2), 2) :|: z = t, z' = 1 + (1 + n''), n'' >= 0, t >= 0
   g(z) -{ 1 }-> 2 :|: z = 2
   g(z) -{ 1 }-> 1 :|: z = 1
   g(z) -{ 1 }-> 1 :|: z = 2
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 1 }-> 0 :|: z = 1
   g(z) -{ 1 }-> 0 :|: z = 2


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

(15) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

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

   f(z, z') -{ 2 }-> f'(z, 2) :|: z' = 2, z >= 0
   f(z, z') -{ 2 }-> f'(z, 1) :|: z >= 0, z' = 1
   f(z, z') -{ 2 }-> f'(z, 1) :|: z' = 2, z >= 0
   f(z, z') -{ 2 }-> f'(z, 0) :|: z >= 0, z' = 0
   f(z, z') -{ 2 }-> f'(z, 0) :|: z >= 0, z' = 1
   f(z, z') -{ 2 }-> f'(z, 0) :|: z' = 2, z >= 0
   f'(z, z') -{ 2 }-> f''(f(foldB(1 + (1 + a) + 0 + c, n1), 1)) :|: z = 1 + a + (1 + n1) + c, a >= 0, c >= 0, n1 >= 0, z' = 0
   f'(z, z') -{ 2 }-> f''(1 + (1 + a) + 0 + c) :|: a >= 0, c >= 0, z = 1 + a + 0 + c, z' = 0
   f'(z, z') -{ 1 }-> f(1 + a + b + c, 0) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c, z' = 1
   f'(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   f'(z, z') -{ 1 }-> 1 + a + b + (1 + c) :|: b >= 0, z' = 2, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 1 }-> foldC(1 + a + b + 0, c) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 0 }-> 0 :|: z >= 0
   foldB(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   foldB(z, z') -{ 2 }-> f(z, 1) :|: z >= 0, z' = 1 + 0
   foldB(z, z') -{ 2 }-> f(f(foldB(z, z' - 2), 1), 1) :|: z' - 2 >= 0, z >= 0
   foldC(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   foldC(z, z') -{ 2 }-> f(z, 2) :|: z >= 0, z' = 1 + 0
   foldC(z, z') -{ 2 }-> f(f(foldC(z, z' - 2), 2), 2) :|: z' - 2 >= 0, z >= 0
   g(z) -{ 1 }-> 2 :|: z = 2
   g(z) -{ 1 }-> 1 :|: z = 1
   g(z) -{ 1 }-> 1 :|: z = 2
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 1 }-> 0 :|: z = 1
   g(z) -{ 1 }-> 0 :|: z = 2


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

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

   f'(v0, v1) -> null_f' [0]
   f''(v0) -> null_f'' [0]

And the following fresh constants:    null_f', null_f''

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

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

   g(A) -> A [1]
   g(B) -> A [1]
   g(B) -> B [1]
   g(C) -> A [1]
   g(C) -> B [1]
   g(C) -> C [1]
   foldB(t, 0) -> t [1]
   foldB(t, s(n)) -> f(foldB(t, n), B) [1]
   foldC(t, 0) -> t [1]
   foldC(t, s(n)) -> f(foldC(t, n), C) [1]
   f(t, x) -> f'(t, g(x)) [1]
   f'(triple(a, b, c), C) -> triple(a, b, s(c)) [1]
   f'(triple(a, b, c), B) -> f(triple(a, b, c), A) [1]
   f'(triple(a, b, c), A) -> f''(foldB(triple(s(a), 0, c), b)) [1]
   f''(triple(a, b, c)) -> foldC(triple(a, b, 0), c) [1]
   f'(v0, v1) -> null_f' [0]
   f''(v0) -> null_f'' [0]

The TRS has the following type information:
g :: A:B:C -> A:B:C
A :: A:B:C
B :: A:B:C
C :: A:B:C
foldB :: triple:null_f':null_f'' -> 0:s -> triple:null_f':null_f''
0 :: 0:s
s :: 0:s -> 0:s
f :: triple:null_f':null_f'' -> A:B:C -> triple:null_f':null_f''
foldC :: triple:null_f':null_f'' -> 0:s -> triple:null_f':null_f''
f' :: triple:null_f':null_f'' -> A:B:C -> triple:null_f':null_f''
triple :: 0:s -> 0:s -> 0:s -> triple:null_f':null_f''
f'' :: triple:null_f':null_f'' -> triple:null_f':null_f''
null_f' :: triple:null_f':null_f''
null_f'' :: triple:null_f':null_f''

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

(19) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   A => 0
   B => 1
   C => 2
   0 => 0
   null_f' => 0
   null_f'' => 0

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

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

   f(z, z') -{ 1 }-> f'(t, g(x)) :|: z' = x, z = t, x >= 0, t >= 0
   f'(z, z') -{ 1 }-> f''(foldB(1 + (1 + a) + 0 + c, b)) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c, z' = 0
   f'(z, z') -{ 1 }-> f(1 + a + b + c, 0) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c, z' = 1
   f'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   f'(z, z') -{ 1 }-> 1 + a + b + (1 + c) :|: b >= 0, z' = 2, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 1 }-> foldC(1 + a + b + 0, c) :|: b >= 0, a >= 0, c >= 0, z = 1 + a + b + c
   f''(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   foldB(z, z') -{ 1 }-> t :|: z = t, t >= 0, z' = 0
   foldB(z, z') -{ 1 }-> f(foldB(t, n), 1) :|: n >= 0, z = t, z' = 1 + n, t >= 0
   foldC(z, z') -{ 1 }-> t :|: z = t, t >= 0, z' = 0
   foldC(z, z') -{ 1 }-> f(foldC(t, n), 2) :|: n >= 0, z = t, z' = 1 + n, t >= 0
   g(z) -{ 1 }-> 2 :|: z = 2
   g(z) -{ 1 }-> 1 :|: z = 1
   g(z) -{ 1 }-> 1 :|: z = 2
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 1 }-> 0 :|: z = 1
   g(z) -{ 1 }-> 0 :|: z = 2

Only complete derivations are relevant for the runtime complexity.

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

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

(22)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   G(A) -> c
   G(B) -> c1
   G(B) -> c2
   G(C) -> c3
   G(C) -> c4
   G(C) -> c5
   FOLDB(z0, 0) -> c6
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, 0) -> c8
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F(z0, z1) -> c10(F'(z0, g(z1)), G(z1))
   F'(triple(z0, z1, z2), C) -> c11
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
S tuples:
   G(A) -> c
   G(B) -> c1
   G(B) -> c2
   G(C) -> c3
   G(C) -> c4
   G(C) -> c5
   FOLDB(z0, 0) -> c6
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, 0) -> c8
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F(z0, z1) -> c10(F'(z0, g(z1)), G(z1))
   F'(triple(z0, z1, z2), C) -> c11
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   G_1, FOLDB_2, FOLDC_2, F_2, F'_2, F''_1

Compound Symbols:   c, c1, c2, c3, c4, c5, c6, c7_2, c8, c9_2, c10_2, c11, c12_1, c13_2, c14_1


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

(23) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   G(C) -> c4
   FOLDB(z0, 0) -> c6
   G(B) -> c2
   G(C) -> c3
   FOLDC(z0, 0) -> c8
   G(B) -> c1
   G(A) -> c
   F'(triple(z0, z1, z2), C) -> c11
   G(C) -> c5

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

(24)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F(z0, z1) -> c10(F'(z0, g(z1)), G(z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F(z0, z1) -> c10(F'(z0, g(z1)), G(z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F_2, F'_2, F''_1

Compound Symbols:   c7_2, c9_2, c10_2, c12_1, c13_2, c14_1


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

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

(26)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c13_2, c14_1, c10_1


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

(27) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F'(triple(z0, z1, z2), A) -> c13(F''(foldB(triple(s(z0), 0, z2), z1)), FOLDB(triple(s(z0), 0, z2), z1)) by 
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)), FOLDB(triple(s(x0), 0, x2), 0))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))

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

(28)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)), FOLDB(triple(s(x0), 0, x2), 0))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)), FOLDB(triple(s(x0), 0, x2), 0))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c14_1, c10_1, c13_2


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

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

(30)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F(z0, z1) -> c10(F'(z0, g(z1)))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c14_1, c10_1, c13_2, c13_1


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

(31) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(z0, z1) -> c10(F'(z0, g(z1))) by 
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, C))

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

(32)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, C))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, C))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c14_1, c13_2, c13_1, c10_1


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

(33) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   F(x0, C) -> c10(F'(x0, C))

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

(34)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1)))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c14_1, c13_2, c13_1, c10_1


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

(35) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F'(triple(x0, s(z1), x2), A) -> c13(F''(f(foldB(triple(s(x0), 0, x2), z1), B)), FOLDB(triple(s(x0), 0, x2), s(z1))) by 
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))

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

(36)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F''_1, F_2

Compound Symbols:   c7_2, c9_2, c12_1, c14_1, c13_1, c10_1, c13_2


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

(37) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F''(triple(z0, z1, z2)) -> c14(FOLDC(triple(z0, z1, 0), z2)) by 
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))

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

(38)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, A) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F_2, F''_1

Compound Symbols:   c7_2, c9_2, c12_1, c13_1, c10_1, c13_2, c14_1


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

(39) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(x0, A) -> c10(F'(x0, A)) by 
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))

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

(40)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2)))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F_2, F''_1

Compound Symbols:   c7_2, c9_2, c12_1, c13_1, c10_1, c13_2, c14_1


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

(41) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(x0, 0, x2), A) -> c13(F''(triple(s(x0), 0, x2))) by 
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))

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

(42)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, B) -> c10(F'(x0, A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F_2, F''_1

Compound Symbols:   c7_2, c9_2, c12_1, c10_1, c13_2, c13_1, c14_1


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

(43) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(x0, B) -> c10(F'(x0, A)) by 
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))

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

(44)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, B) -> c10(F'(x0, B))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F_2, F''_1

Compound Symbols:   c7_2, c9_2, c12_1, c10_1, c13_2, c13_1, c14_1


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

(45) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(x0, B) -> c10(F'(x0, B)) by 
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))

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

(46)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
S tuples:
   FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1))
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDB_2, FOLDC_2, F'_2, F_2, F''_1

Compound Symbols:   c7_2, c9_2, c12_1, c10_1, c13_2, c13_1, c14_1


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

(47) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FOLDB(z0, s(z1)) -> c7(F(foldB(z0, z1), B), FOLDB(z0, z1)) by 
   FOLDB(z0, s(0)) -> c7(F(z0, B), FOLDB(z0, 0))
   FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1)))

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

(48)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B), FOLDB(z0, 0))
   FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1)))
S tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B), FOLDB(z0, 0))
   FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDC_2, F'_2, F_2, F''_1, FOLDB_2

Compound Symbols:   c9_2, c12_1, c10_1, c13_2, c13_1, c14_1, c7_2


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

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

(50)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1)))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
S tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1)))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDC_2, F'_2, F_2, F''_1, FOLDB_2

Compound Symbols:   c9_2, c12_1, c10_1, c13_2, c13_1, c14_1, c7_2, c7_1


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

(51) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FOLDB(z0, s(s(z1))) -> c7(F(f(foldB(z0, z1), B), B), FOLDB(z0, s(z1))) by 
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
S tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDC_2, F'_2, F_2, F''_1, FOLDB_2

Compound Symbols:   c9_2, c12_1, c10_1, c13_2, c13_1, c14_1, c7_1, c7_2


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

(53) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(x0, C) -> c10(F'(x0, A)) by 
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))

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

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
S tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F(x0, C) -> c10(F'(x0, B))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDC_2, F'_2, F_2, F''_1, FOLDB_2

Compound Symbols:   c9_2, c12_1, c10_1, c13_2, c13_1, c14_1, c7_1, c7_2


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

(55) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(x0, C) -> c10(F'(x0, B)) by 
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
S tuples:
   FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1))
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   FOLDC_2, F'_2, F''_1, F_2, FOLDB_2

Compound Symbols:   c9_2, c12_1, c13_2, c13_1, c14_1, c10_1, c7_1, c7_2


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

(57) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FOLDC(z0, s(z1)) -> c9(F(foldC(z0, z1), C), FOLDC(z0, z1)) by 
   FOLDC(z0, s(0)) -> c9(F(z0, C), FOLDC(z0, 0))
   FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1)))

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C), FOLDC(z0, 0))
   FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1)))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C), FOLDC(z0, 0))
   FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1)))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F''_1, F_2, FOLDB_2, FOLDC_2

Compound Symbols:   c12_1, c13_2, c13_1, c14_1, c10_1, c7_1, c7_2, c9_2


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

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

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1)))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1)))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F''_1, F_2, FOLDB_2, FOLDC_2

Compound Symbols:   c12_1, c13_2, c13_1, c14_1, c10_1, c7_1, c7_2, c9_2, c9_1


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

(61) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace FOLDC(z0, s(s(z1))) -> c9(F(f(foldC(z0, z1), C), C), FOLDC(z0, s(z1))) by 
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1)))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F''_1, F_2, FOLDB_2, FOLDC_2

Compound Symbols:   c12_1, c13_2, c13_1, c14_1, c10_1, c7_1, c7_2, c9_1, c9_2


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

(63) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(x0, s(x1), x2), A) -> c13(FOLDB(triple(s(x0), 0, x2), s(x1))) by 
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1)))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F''_1, F_2, FOLDB_2, FOLDC_2

Compound Symbols:   c12_1, c13_2, c14_1, c10_1, c13_1, c7_1, c7_2, c9_1, c9_2


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

(65) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F''(triple(z0, z1, s(y1))) -> c14(FOLDC(triple(z0, z1, 0), s(y1))) by 
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c12_1, c13_2, c10_1, c13_1, c7_1, c7_2, c9_1, c9_2, c14_1


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

(67) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(x0, x1, x2), A) -> c10(F'(triple(x0, x1, x2), A)) by 
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
S tuples:
   F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A))
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c12_1, c13_2, c13_1, c10_1, c7_1, c7_2, c9_1, c9_2, c14_1


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

(69) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(z0, z1, z2), B) -> c12(F(triple(z0, z1, z2), A)) by 
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c13_1, c10_1, c7_1, c7_2, c9_1, c9_2, c14_1, c12_1


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

(71) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(z0, 0, s(y2)), A) -> c13(F''(triple(s(z0), 0, s(y2)))) by 
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1


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

(73) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(y0, 0, s(y1)), B) -> c10(F'(triple(y0, 0, s(y1)), A)) by 
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1


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

(75) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(y0, y1, y2), B) -> c10(F'(triple(y0, y1, y2), B)) by 
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(z0, s(0)) -> c7(F(z0, B))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1


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

(77) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FOLDB(z0, s(0)) -> c7(F(z0, B)) by 
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
K tuples:none
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1, c7_1


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

(79) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
We considered the (Usable) Rules:none
And the Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(A) = 0
   POL(B) = 0
   POL(C) = 0
   POL(F(x_1, x_2)) = x_2
   POL(F'(x_1, x_2)) = x_2
   POL(F''(x_1)) = 0
   POL(FOLDB(x_1, x_2)) = x_1
   POL(FOLDC(x_1, x_2)) = 0
   POL(c10(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c7(x_1, x_2)) = x_1 + x_2
   POL(c9(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f(x_1, x_2)) = 0
   POL(f'(x_1, x_2)) = [1]
   POL(f''(x_1)) = [1] + x_1
   POL(foldB(x_1, x_2)) = x_2
   POL(foldC(x_1, x_2)) = [1] + x_1 + x_2
   POL(g(x_1)) = [1] + x_1
   POL(s(x_1)) = [1] + x_1
   POL(triple(x_1, x_2, x_3)) = x_2

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1, c7_1


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

(81) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(y0, 0, s(y1)), C) -> c10(F'(triple(y0, 0, s(y1)), A)) by 
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1, c7_1


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

(83) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(y0, y1, y2), C) -> c10(F'(triple(y0, y1, y2), B)) by 
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(z0, s(0)) -> c9(F(z0, C))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_1, c9_2, c13_1, c14_1, c12_1, c7_1


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

(85) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace FOLDC(z0, s(0)) -> c9(F(z0, C)) by 
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(87) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
We considered the (Usable) Rules:none
And the Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(A) = 0
   POL(B) = 0
   POL(C) = 0
   POL(F(x_1, x_2)) = x_2
   POL(F'(x_1, x_2)) = x_2
   POL(F''(x_1)) = 0
   POL(FOLDB(x_1, x_2)) = 0
   POL(FOLDC(x_1, x_2)) = x_1
   POL(c10(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c7(x_1, x_2)) = x_1 + x_2
   POL(c9(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f(x_1, x_2)) = 0
   POL(f'(x_1, x_2)) = [1]
   POL(f''(x_1)) = [1] + x_1
   POL(foldB(x_1, x_2)) = x_2
   POL(foldC(x_1, x_2)) = [1] + x_1 + x_2
   POL(g(x_1)) = [1] + x_1
   POL(s(x_1)) = [1] + x_1
   POL(triple(x_1, x_2, x_3)) = x_3

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(89) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
We considered the (Usable) Rules:
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f(z0, z1) -> f'(z0, g(z1))
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   foldC(z0, 0) -> z0
   foldB(z0, 0) -> z0
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
And the Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(A) = 0
   POL(B) = 0
   POL(C) = 0
   POL(F(x_1, x_2)) = x_2
   POL(F'(x_1, x_2)) = x_2
   POL(F''(x_1)) = x_1
   POL(FOLDB(x_1, x_2)) = 0
   POL(FOLDC(x_1, x_2)) = x_1
   POL(c10(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c7(x_1, x_2)) = x_1 + x_2
   POL(c9(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f(x_1, x_2)) = x_1
   POL(f'(x_1, x_2)) = x_1
   POL(f''(x_1)) = x_1
   POL(foldB(x_1, x_2)) = x_1
   POL(foldC(x_1, x_2)) = x_1
   POL(g(x_1)) = [1] + x_1
   POL(s(x_1)) = [1]
   POL(triple(x_1, x_2, x_3)) = x_2

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0)))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(91) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(z0, s(0), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(0))) by 
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(93) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(triple(z0, 0, s(y1)), A) -> c10(F'(triple(z0, 0, s(y1)), A)) by 
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(95) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F'(triple(z0, 0, s(y1)), B) -> c12(F(triple(z0, 0, s(y1)), A)) by 
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0)))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(97) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F''(triple(z0, z1, s(0))) -> c14(FOLDC(triple(z0, z1, 0), s(0))) by 
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(99) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 5 trailing nodes:
   F'(triple(z0, 0, s(0)), B) -> c12(F(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(0)), B) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(0)), A) -> c10(F'(triple(z0, 0, s(0)), A))
   F(triple(z0, 0, s(0)), C) -> c10(F'(triple(z0, 0, s(0)), A))
   F'(triple(z0, 0, s(0)), A) -> c13(F''(triple(s(z0), 0, s(0))))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1


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

(101) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
We considered the (Usable) Rules:
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f(z0, z1) -> f'(z0, g(z1))
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   foldC(z0, 0) -> z0
   foldB(z0, 0) -> z0
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
And the Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(A) = 0
   POL(B) = 0
   POL(C) = 0
   POL(F(x_1, x_2)) = x_2
   POL(F'(x_1, x_2)) = x_2
   POL(F''(x_1)) = x_1
   POL(FOLDB(x_1, x_2)) = 0
   POL(FOLDC(x_1, x_2)) = 0
   POL(c10(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c7(x_1, x_2)) = x_1 + x_2
   POL(c9(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f(x_1, x_2)) = x_1
   POL(f'(x_1, x_2)) = x_1
   POL(f''(x_1)) = x_1
   POL(foldB(x_1, x_2)) = x_1
   POL(foldC(x_1, x_2)) = x_1
   POL(g(x_1)) = [1] + x_1
   POL(s(x_1)) = [1]
   POL(triple(x_1, x_2, x_3)) = x_2

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g(A) -> A
   g(B) -> A
   g(B) -> B
   g(C) -> A
   g(C) -> B
   g(C) -> C
   foldB(z0, 0) -> z0
   foldB(z0, s(z1)) -> f(foldB(z0, z1), B)
   foldC(z0, 0) -> z0
   foldC(z0, s(z1)) -> f(foldC(z0, z1), C)
   f(z0, z1) -> f'(z0, g(z1))
   f'(triple(z0, z1, z2), C) -> triple(z0, z1, s(z2))
   f'(triple(z0, z1, z2), B) -> f(triple(z0, z1, z2), A)
   f'(triple(z0, z1, z2), A) -> f''(foldB(triple(s(z0), 0, z2), z1))
   f''(triple(z0, z1, z2)) -> foldC(triple(z0, z1, 0), z2)
Tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
S tuples:
   F'(triple(x0, s(x1), x2), A) -> c13(F''(f'(foldB(triple(s(x0), 0, x2), x1), g(B))), FOLDB(triple(s(x0), 0, x2), s(x1)))
   F'(triple(x0, s(0), x2), A) -> c13(F''(f(triple(s(x0), 0, x2), B)), FOLDB(triple(s(x0), 0, x2), s(0)))
   F'(triple(x0, s(s(z1)), x2), A) -> c13(F''(f(f(foldB(triple(s(x0), 0, x2), z1), B), B)), FOLDB(triple(s(x0), 0, x2), s(s(z1))))
   F(triple(y0, s(y1), y2), B) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), B) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), B) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDB(x0, s(s(x1))) -> c7(F(f'(foldB(x0, x1), g(B)), B), FOLDB(x0, s(x1)))
   FOLDB(z0, s(s(0))) -> c7(F(f(z0, B), B), FOLDB(z0, s(0)))
   FOLDB(z0, s(s(s(z1)))) -> c7(F(f(f(foldB(z0, z1), B), B), B), FOLDB(z0, s(s(z1))))
   F(triple(y0, s(y1), y2), C) -> c10(F'(triple(y0, s(y1), y2), A))
   F(triple(y0, s(0), y1), C) -> c10(F'(triple(y0, s(0), y1), A))
   F(triple(y0, s(s(y1)), y2), C) -> c10(F'(triple(y0, s(s(y1)), y2), A))
   FOLDC(x0, s(s(x1))) -> c9(F(f'(foldC(x0, x1), g(C)), C), FOLDC(x0, s(x1)))
   FOLDC(z0, s(s(0))) -> c9(F(f(z0, C), C), FOLDC(z0, s(0)))
   FOLDC(z0, s(s(s(z1)))) -> c9(F(f(f(foldC(z0, z1), C), C), C), FOLDC(z0, s(s(z1))))
   F'(triple(z0, s(s(y1)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(y1))))
   F'(triple(z0, s(s(0)), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(0))))
   F'(triple(z0, s(s(s(y1))), z2), A) -> c13(FOLDB(triple(s(z0), 0, z2), s(s(s(y1)))))
   F''(triple(z0, z1, s(s(y1)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(y1))))
   F''(triple(z0, z1, s(s(0)))) -> c14(FOLDC(triple(z0, z1, 0), s(s(0))))
   F''(triple(z0, z1, s(s(s(y1))))) -> c14(FOLDC(triple(z0, z1, 0), s(s(s(y1)))))
   F(triple(z0, s(y1), z2), A) -> c10(F'(triple(z0, s(y1), z2), A))
   F(triple(z0, s(0), z2), A) -> c10(F'(triple(z0, s(0), z2), A))
   F(triple(z0, s(s(y1)), z2), A) -> c10(F'(triple(z0, s(s(y1)), z2), A))
   F(triple(z0, s(s(0)), z2), A) -> c10(F'(triple(z0, s(s(0)), z2), A))
   F(triple(z0, s(s(s(y1))), z2), A) -> c10(F'(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, s(y1), z2), B) -> c12(F(triple(z0, s(y1), z2), A))
   F'(triple(z0, s(0), z2), B) -> c12(F(triple(z0, s(0), z2), A))
   F'(triple(z0, s(s(y1)), z2), B) -> c12(F(triple(z0, s(s(y1)), z2), A))
   F'(triple(z0, s(s(0)), z2), B) -> c12(F(triple(z0, s(s(0)), z2), A))
   F'(triple(z0, s(s(s(y1))), z2), B) -> c12(F(triple(z0, s(s(s(y1))), z2), A))
   F'(triple(z0, 0, s(s(y2))), A) -> c13(F''(triple(s(z0), 0, s(s(y2)))))
   F'(triple(z0, 0, s(s(0))), A) -> c13(F''(triple(s(z0), 0, s(s(0)))))
   F'(triple(z0, 0, s(s(s(y2)))), A) -> c13(F''(triple(s(z0), 0, s(s(s(y2))))))
   F(triple(z0, 0, s(s(y1))), B) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), B) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), B) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), B) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), B) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), B) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), B) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), B) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), B) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   FOLDB(triple(y0, 0, s(0)), s(0)) -> c7(F(triple(y0, 0, s(0)), B))
   FOLDB(triple(y0, 0, s(s(y1))), s(0)) -> c7(F(triple(y0, 0, s(s(y1))), B))
   FOLDB(triple(y0, 0, s(s(0))), s(0)) -> c7(F(triple(y0, 0, s(s(0))), B))
   FOLDB(triple(y0, 0, s(s(s(y1)))), s(0)) -> c7(F(triple(y0, 0, s(s(s(y1)))), B))
   FOLDB(triple(y0, 0, s(y1)), s(0)) -> c7(F(triple(y0, 0, s(y1)), B))
   F(triple(z0, 0, s(s(y1))), C) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), C) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), C) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F(triple(z0, s(y1), z2), C) -> c10(F'(triple(z0, s(y1), z2), B))
   F(triple(z0, s(0), z2), C) -> c10(F'(triple(z0, s(0), z2), B))
   F(triple(z0, s(s(y1)), z2), C) -> c10(F'(triple(z0, s(s(y1)), z2), B))
   F(triple(z0, 0, s(y1)), C) -> c10(F'(triple(z0, 0, s(y1)), B))
   F(triple(z0, s(s(0)), z2), C) -> c10(F'(triple(z0, s(s(0)), z2), B))
   F(triple(z0, s(s(s(y1))), z2), C) -> c10(F'(triple(z0, s(s(s(y1))), z2), B))
   F'(triple(z0, s(0), s(0)), A) -> c13(FOLDB(triple(s(z0), 0, s(0)), s(0)))
   F'(triple(z0, s(0), s(s(y1))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(y1))), s(0)))
   F'(triple(z0, s(0), s(s(0))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(0))), s(0)))
   F'(triple(z0, s(0), s(s(s(y1)))), A) -> c13(FOLDB(triple(s(z0), 0, s(s(s(y1)))), s(0)))
   F'(triple(z0, s(0), s(y1)), A) -> c13(FOLDB(triple(s(z0), 0, s(y1)), s(0)))
   F(triple(z0, 0, s(s(y1))), A) -> c10(F'(triple(z0, 0, s(s(y1))), A))
   F(triple(z0, 0, s(s(0))), A) -> c10(F'(triple(z0, 0, s(s(0))), A))
   F(triple(z0, 0, s(s(s(y1)))), A) -> c10(F'(triple(z0, 0, s(s(s(y1)))), A))
   F'(triple(z0, 0, s(s(y1))), B) -> c12(F(triple(z0, 0, s(s(y1))), A))
   F'(triple(z0, 0, s(s(0))), B) -> c12(F(triple(z0, 0, s(s(0))), A))
   F'(triple(z0, 0, s(s(s(y1)))), B) -> c12(F(triple(z0, 0, s(s(s(y1)))), A))
K tuples:
   FOLDB(triple(y0, s(y1), y2), s(0)) -> c7(F(triple(y0, s(y1), y2), B))
   FOLDB(triple(y0, s(0), y1), s(0)) -> c7(F(triple(y0, s(0), y1), B))
   FOLDB(triple(y0, s(s(y1)), y2), s(0)) -> c7(F(triple(y0, s(s(y1)), y2), B))
   FOLDB(triple(y0, s(s(0)), y1), s(0)) -> c7(F(triple(y0, s(s(0)), y1), B))
   FOLDB(triple(y0, s(s(s(y1))), y2), s(0)) -> c7(F(triple(y0, s(s(s(y1))), y2), B))
   FOLDC(triple(y0, 0, s(0)), s(0)) -> c9(F(triple(y0, 0, s(0)), C))
   FOLDC(triple(y0, 0, s(s(y1))), s(0)) -> c9(F(triple(y0, 0, s(s(y1))), C))
   FOLDC(triple(y0, 0, s(s(0))), s(0)) -> c9(F(triple(y0, 0, s(s(0))), C))
   FOLDC(triple(y0, 0, s(s(s(y1)))), s(0)) -> c9(F(triple(y0, 0, s(s(s(y1)))), C))
   FOLDC(triple(y0, 0, s(y1)), s(0)) -> c9(F(triple(y0, 0, s(y1)), C))
   FOLDC(triple(y0, s(y1), y2), s(0)) -> c9(F(triple(y0, s(y1), y2), C))
   FOLDC(triple(y0, s(0), y1), s(0)) -> c9(F(triple(y0, s(0), y1), C))
   FOLDC(triple(y0, s(s(y1)), y2), s(0)) -> c9(F(triple(y0, s(s(y1)), y2), C))
   FOLDC(triple(y0, s(s(0)), y1), s(0)) -> c9(F(triple(y0, s(s(0)), y1), C))
   FOLDC(triple(y0, s(s(s(y1))), y2), s(0)) -> c9(F(triple(y0, s(s(s(y1))), y2), C))
   F''(triple(z0, s(y1), s(0))) -> c14(FOLDC(triple(z0, s(y1), 0), s(0)))
   F''(triple(z0, s(0), s(0))) -> c14(FOLDC(triple(z0, s(0), 0), s(0)))
   F''(triple(z0, s(s(y1)), s(0))) -> c14(FOLDC(triple(z0, s(s(y1)), 0), s(0)))
   F''(triple(z0, s(s(0)), s(0))) -> c14(FOLDC(triple(z0, s(s(0)), 0), s(0)))
   F''(triple(z0, s(s(s(y1))), s(0))) -> c14(FOLDC(triple(z0, s(s(s(y1))), 0), s(0)))
Defined Rule Symbols:   g_1, foldB_2, foldC_2, f_2, f'_2, f''_1

Defined Pair Symbols:   F'_2, F_2, FOLDB_2, FOLDC_2, F''_1

Compound Symbols:   c13_2, c10_1, c7_2, c9_2, c13_1, c14_1, c12_1, c7_1, c9_1