/export/starexec/sandbox/solver/bin/starexec_run_standard /export/starexec/sandbox/benchmark/theBenchmark.pl /export/starexec/sandbox/output/output_files


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


MAYBE
proof of /export/starexec/sandbox/benchmark/theBenchmark.pl
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Left Termination of the query pattern

main(g,a)

w.r.t. the given Prolog program could not be shown:

(0) Prolog
(1) IntegerArithmeticTransformerProof [SOUND, 0 ms]
(2) Prolog
    (3) NotTransformerProof [EQUIVALENT, 0 ms]
    (4) Prolog
    (5) CallTransformerProof [EQUIVALENT, 0 ms]
    (6) Prolog
    (7) CutEliminatorProof [SOUND, 0 ms]
    (8) Prolog
    (9) FailTransformerProof [EQUIVALENT, 0 ms]
    (10) Prolog
    (11) UnifyTransformerProof [EQUIVALENT, 0 ms]
    (12) Prolog
    (13) PrologToPiTRSProof [SOUND, 6 ms]
    (14) PiTRS
        (15) DependencyPairsProof [EQUIVALENT, 212 ms]
        (16) PiDP
        (17) DependencyGraphProof [EQUIVALENT, 0 ms]
        (18) AND
            (19) PiDP
                (20) UsableRulesProof [EQUIVALENT, 0 ms]
                (21) PiDP
                (22) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (23) QDP
                (24) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (25) YES
            (26) PiDP
                (27) UsableRulesProof [EQUIVALENT, 0 ms]
                (28) PiDP
                (29) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (30) QDP
                (31) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (32) YES
            (33) PiDP
                (34) UsableRulesProof [EQUIVALENT, 0 ms]
                (35) PiDP
                (36) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (37) QDP
                (38) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (39) YES
            (40) PiDP
                (41) UsableRulesProof [EQUIVALENT, 0 ms]
                (42) PiDP
                (43) PiDPToQDPProof [SOUND, 0 ms]
                (44) QDP
                (45) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (46) YES
            (47) PiDP
                (48) UsableRulesProof [EQUIVALENT, 0 ms]
                (49) PiDP
                (50) PiDPToQDPProof [SOUND, 0 ms]
                (51) QDP
                (52) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (53) YES
            (54) PiDP
                (55) UsableRulesProof [EQUIVALENT, 0 ms]
                (56) PiDP
                (57) PiDPToQDPProof [SOUND, 0 ms]
                (58) QDP
                (59) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (60) YES
            (61) PiDP
                (62) UsableRulesProof [EQUIVALENT, 0 ms]
                (63) PiDP
                (64) PiDPToQDPProof [SOUND, 0 ms]
                (65) QDP
                (66) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (67) YES
            (68) PiDP
                (69) UsableRulesProof [EQUIVALENT, 0 ms]
                (70) PiDP
                (71) PiDPToQDPProof [SOUND, 0 ms]
                (72) QDP
                (73) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (74) YES
            (75) PiDP
                (76) UsableRulesProof [EQUIVALENT, 0 ms]
                (77) PiDP
                (78) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (79) QDP
                (80) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (81) YES
            (82) PiDP
                (83) UsableRulesProof [EQUIVALENT, 0 ms]
                (84) PiDP
                (85) PiDPToQDPProof [SOUND, 7 ms]
                (86) QDP
                (87) TransformationProof [EQUIVALENT, 8 ms]
                (88) QDP
                (89) TransformationProof [EQUIVALENT, 0 ms]
                (90) QDP
                (91) TransformationProof [EQUIVALENT, 0 ms]
                (92) QDP
                (93) TransformationProof [EQUIVALENT, 0 ms]
                (94) QDP
                (95) UsableRulesProof [EQUIVALENT, 0 ms]
                (96) QDP
                (97) QReductionProof [EQUIVALENT, 0 ms]
                (98) QDP
                (99) TransformationProof [SOUND, 0 ms]
                (100) QDP
                (101) TransformationProof [SOUND, 2 ms]
                (102) QDP
                (103) UsableRulesProof [EQUIVALENT, 0 ms]
                (104) QDP
                (105) QReductionProof [EQUIVALENT, 0 ms]
                (106) QDP
                (107) TransformationProof [SOUND, 0 ms]
                (108) QDP
                (109) UsableRulesProof [EQUIVALENT, 0 ms]
                (110) QDP
                (111) QReductionProof [EQUIVALENT, 0 ms]
                (112) QDP
                (113) TransformationProof [EQUIVALENT, 0 ms]
                (114) QDP
                (115) UsableRulesProof [EQUIVALENT, 0 ms]
                (116) QDP
                (117) QReductionProof [EQUIVALENT, 0 ms]
                (118) QDP
                (119) TransformationProof [EQUIVALENT, 0 ms]
                (120) QDP
                (121) TransformationProof [SOUND, 0 ms]
                (122) QDP
                (123) UsableRulesProof [EQUIVALENT, 0 ms]
                (124) QDP
                (125) QReductionProof [EQUIVALENT, 0 ms]
                (126) QDP
                (127) TransformationProof [EQUIVALENT, 0 ms]
                (128) QDP
                (129) UsableRulesProof [EQUIVALENT, 0 ms]
                (130) QDP
    (131) PrologToPiTRSProof [SOUND, 16 ms]
    (132) PiTRS
        (133) DependencyPairsProof [EQUIVALENT, 196 ms]
        (134) PiDP
        (135) DependencyGraphProof [EQUIVALENT, 0 ms]
        (136) AND
            (137) PiDP
                (138) UsableRulesProof [EQUIVALENT, 0 ms]
                (139) PiDP
                (140) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (141) QDP
                (142) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (143) YES
            (144) PiDP
                (145) UsableRulesProof [EQUIVALENT, 0 ms]
                (146) PiDP
                (147) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (148) QDP
                (149) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (150) YES
            (151) PiDP
                (152) UsableRulesProof [EQUIVALENT, 0 ms]
                (153) PiDP
                (154) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (155) QDP
                (156) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (157) YES
            (158) PiDP
                (159) UsableRulesProof [EQUIVALENT, 0 ms]
                (160) PiDP
                (161) PiDPToQDPProof [SOUND, 0 ms]
                (162) QDP
                (163) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (164) YES
            (165) PiDP
                (166) UsableRulesProof [EQUIVALENT, 0 ms]
                (167) PiDP
                (168) PiDPToQDPProof [SOUND, 0 ms]
                (169) QDP
                (170) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (171) YES
            (172) PiDP
                (173) UsableRulesProof [EQUIVALENT, 0 ms]
                (174) PiDP
                (175) PiDPToQDPProof [SOUND, 0 ms]
                (176) QDP
                (177) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (178) YES
            (179) PiDP
                (180) UsableRulesProof [EQUIVALENT, 0 ms]
                (181) PiDP
                (182) PiDPToQDPProof [SOUND, 0 ms]
                (183) QDP
                (184) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (185) YES
            (186) PiDP
                (187) UsableRulesProof [EQUIVALENT, 0 ms]
                (188) PiDP
                (189) PiDPToQDPProof [SOUND, 0 ms]
                (190) QDP
                (191) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (192) YES
            (193) PiDP
                (194) UsableRulesProof [EQUIVALENT, 0 ms]
                (195) PiDP
                (196) PiDPToQDPProof [EQUIVALENT, 0 ms]
                (197) QDP
                (198) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (199) YES
            (200) PiDP
                (201) UsableRulesProof [EQUIVALENT, 0 ms]
                (202) PiDP
                (203) PiDPToQDPProof [SOUND, 0 ms]
                (204) QDP
                (205) TransformationProof [EQUIVALENT, 0 ms]
                (206) QDP
                (207) TransformationProof [EQUIVALENT, 0 ms]
                (208) QDP
                (209) TransformationProof [EQUIVALENT, 0 ms]
                (210) QDP
                (211) TransformationProof [EQUIVALENT, 0 ms]
                (212) QDP
                (213) UsableRulesProof [EQUIVALENT, 0 ms]
                (214) QDP
                (215) QReductionProof [EQUIVALENT, 0 ms]
                (216) QDP
                (217) TransformationProof [SOUND, 0 ms]
                (218) QDP
                (219) TransformationProof [SOUND, 0 ms]
                (220) QDP
                (221) UsableRulesProof [EQUIVALENT, 0 ms]
                (222) QDP
                (223) QReductionProof [EQUIVALENT, 0 ms]
                (224) QDP
                (225) TransformationProof [SOUND, 0 ms]
                (226) QDP
                (227) UsableRulesProof [EQUIVALENT, 0 ms]
                (228) QDP
                (229) QReductionProof [EQUIVALENT, 0 ms]
                (230) QDP
                (231) TransformationProof [EQUIVALENT, 7 ms]
                (232) QDP
                (233) UsableRulesProof [EQUIVALENT, 0 ms]
                (234) QDP
                (235) QReductionProof [EQUIVALENT, 0 ms]
                (236) QDP
                (237) TransformationProof [EQUIVALENT, 0 ms]
                (238) QDP
                (239) TransformationProof [SOUND, 0 ms]
                (240) QDP
                (241) UsableRulesProof [EQUIVALENT, 0 ms]
                (242) QDP
                (243) QReductionProof [EQUIVALENT, 0 ms]
                (244) QDP
                (245) TransformationProof [EQUIVALENT, 0 ms]
                (246) QDP
                (247) UsableRulesProof [EQUIVALENT, 0 ms]
                (248) QDP
                (249) QReductionProof [EQUIVALENT, 0 ms]
                (250) QDP
                (251) TransformationProof [EQUIVALENT, 0 ms]
                (252) QDP
                (253) UsableRulesProof [EQUIVALENT, 0 ms]
                (254) QDP
                (255) QReductionProof [EQUIVALENT, 0 ms]
                (256) QDP
                (257) TransformationProof [EQUIVALENT, 0 ms]
                (258) QDP
                (259) DependencyGraphProof [EQUIVALENT, 0 ms]
                (260) QDP
                (261) UsableRulesProof [EQUIVALENT, 0 ms]
                (262) QDP
(263) CutEliminatorProof [SOUND, 0 ms]
(264) Prolog
    (265) UndefinedPredicateHandlerProof [SOUND, 0 ms]
    (266) Prolog
    (267) PrologToPiTRSProof [SOUND, 36 ms]
    (268) PiTRS
        (269) DependencyPairsProof [EQUIVALENT, 30 ms]
        (270) PiDP
        (271) DependencyGraphProof [EQUIVALENT, 0 ms]
        (272) PiDP
        (273) UsableRulesProof [EQUIVALENT, 0 ms]
        (274) PiDP
        (275) PiDPToQDPProof [SOUND, 0 ms]
        (276) QDP
        (277) TransformationProof [EQUIVALENT, 0 ms]
        (278) QDP
        (279) UsableRulesProof [EQUIVALENT, 0 ms]
        (280) QDP
        (281) QReductionProof [EQUIVALENT, 0 ms]
        (282) QDP
        (283) TransformationProof [EQUIVALENT, 0 ms]
        (284) QDP
        (285) TransformationProof [EQUIVALENT, 0 ms]
        (286) QDP
        (287) UsableRulesProof [EQUIVALENT, 0 ms]
        (288) QDP
        (289) QReductionProof [EQUIVALENT, 0 ms]
        (290) QDP
        (291) TransformationProof [EQUIVALENT, 0 ms]
        (292) QDP
        (293) UsableRulesProof [EQUIVALENT, 0 ms]
        (294) QDP
        (295) QReductionProof [EQUIVALENT, 0 ms]
        (296) QDP
        (297) NonTerminationLoopProof [COMPLETE, 0 ms]
        (298) NO
    (299) PrologToPiTRSProof [SOUND, 22 ms]
    (300) PiTRS
        (301) DependencyPairsProof [EQUIVALENT, 16 ms]
        (302) PiDP
        (303) DependencyGraphProof [EQUIVALENT, 0 ms]
        (304) PiDP
        (305) UsableRulesProof [EQUIVALENT, 0 ms]
        (306) PiDP
        (307) PiDPToQDPProof [SOUND, 0 ms]
        (308) QDP
        (309) TransformationProof [EQUIVALENT, 0 ms]
        (310) QDP
        (311) UsableRulesProof [EQUIVALENT, 0 ms]
        (312) QDP
        (313) QReductionProof [EQUIVALENT, 0 ms]
        (314) QDP
        (315) TransformationProof [EQUIVALENT, 0 ms]
        (316) QDP
        (317) TransformationProof [EQUIVALENT, 0 ms]
        (318) QDP
        (319) UsableRulesProof [EQUIVALENT, 0 ms]
        (320) QDP
        (321) QReductionProof [EQUIVALENT, 0 ms]
        (322) QDP
        (323) TransformationProof [EQUIVALENT, 0 ms]
        (324) QDP
        (325) UsableRulesProof [EQUIVALENT, 0 ms]
        (326) QDP
        (327) QReductionProof [EQUIVALENT, 0 ms]
        (328) QDP
(329) PrologToIRSwTTransformerProof [SOUND, 69 ms]
(330) IRSwT
    (331) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms]
    (332) IRSwT
    (333) IntTRSCompressionProof [EQUIVALENT, 59 ms]
    (334) IRSwT
    (335) IRSFormatTransformerProof [EQUIVALENT, 0 ms]
    (336) IRSwT
    (337) IRSwTTerminationDigraphProof [EQUIVALENT, 38 ms]
    (338) IRSwT
    (339) IntTRSCompressionProof [EQUIVALENT, 0 ms]
    (340) IRSwT
    (341) TempFilterProof [SOUND, 69 ms]
    (342) IRSwT
    (343) IRSwTTerminationDigraphProof [EQUIVALENT, 1 ms]
    (344) IRSwT


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

(0)
Obligation:
Clauses:

main(X, Ret) :- twoWay(1, X, Ret).
twoWay(Terminate, N, 1) :- ','(<(N, 0), !).
twoWay(Terminate, N, Ret) :- ','(=:=(Terminate, 1), ','(!, ','(is(M, -(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M)))))).
twoWay(Terminate, N, Ret) :- ','(=\=(Terminate, 1), ','(!, ','(is(M, +(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M)))))).


Query: main(g,a)
----------------------------------------

(1) IntegerArithmeticTransformerProof (SOUND)
Added definitions of predefined predicates [PROLOG].
----------------------------------------

(2)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), ','(isLess(X, X1), !))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(!, ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(!, ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
nounify(X, Y) :- \+(=(X, Y)).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).


Query: main(g,a)
----------------------------------------

(3) NotTransformerProof (EQUIVALENT)
Transformed all not-constructs [PROLOG].
----------------------------------------

(4)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), ','(isLess(X, X1), !))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(!, ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(!, ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
nounify(X, Y) :- not(X, Y).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).
not(X, Y) :- ','(call(=(X, Y)), ','(!, fail)).
not(X, Y).


Query: main(g,a)
----------------------------------------

(5) CallTransformerProof (EQUIVALENT)
Transformed all call-constructs [PROLOG].
----------------------------------------

(6)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), ','(isLess(X, X1), !))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(!, ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(!, ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U))))))))).
nounify(X, Y) :- not(X, Y).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).
not(X, Y) :- ','(call1(X, Y), ','(!, fail)).
not(X, Y).
call1(X, Y) :- =(X, Y).


Query: main(g,a)
----------------------------------------

(7) CutEliminatorProof (SOUND)
Eliminated all cuts by simply ignoring them[PROLOG].
----------------------------------------

(8)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), isLess(X, X1))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
nounify(X, Y) :- not(X, Y).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).
not(X, Y) :- ','(call1(X, Y), fail).
not(X, Y).
call1(X, Y) :- =(X, Y).


Query: main(g,a)
----------------------------------------

(9) FailTransformerProof (EQUIVALENT)
Added clauses for the built-in fail predicate [PROLOG].
----------------------------------------

(10)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), isLess(X, X1))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
nounify(X, Y) :- not(X, Y).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).
not(X, Y) :- ','(call1(X, Y), fail).
not(X, Y).
call1(X, Y) :- =(X, Y).
fail :- failure(a).
failure(b).


Query: main(g,a)
----------------------------------------

(11) UnifyTransformerProof (EQUIVALENT)
Added a fact for the built-in = predicate [PROLOG].
----------------------------------------

(12)
Obligation:
Clauses:

main(X, Ret) :- twoWay(succ(zero), X, Ret).
twoWay(Terminate, N, succ(zero)) :- ','(=(X, N), ','(=(X1, zero), isLess(X, X1))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(=(X, X1), ','(isMinus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
twoWay(Terminate, N, Ret) :- ','(=(X, Terminate), ','(=(X1, succ(zero)), ','(nounify(X, X1), ','(isPlus(N, succ(zero), U), ','(=(M, U), ','(twoWay(Terminate, M, Ret1), ','(isTimes(Ret1, M, U), =(Ret, U)))))))).
nounify(X, Y) :- not(X, Y).
isPlus(zero, X, X).
isPlus(succ(X), zero, succ(X)).
isPlus(succ(X), succ(Y), succ(succ(Z))) :- isPlus(X, Y, Z).
isPlus(succ(X), pred(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), zero, pred(X)).
isPlus(pred(X), succ(Y), Z) :- isPlus(X, Y, Z).
isPlus(pred(X), pred(Y), pred(pred(Z))) :- isPlus(X, Y, Z).
isMinus(X, zero, X).
isMinus(zero, succ(Y), pred(Z)) :- isMinus(zero, Y, Z).
isMinus(zero, pred(Y), succ(Z)) :- isMinus(zero, Y, Z).
isMinus(succ(X), succ(Y), Z) :- isMinus(X, Y, Z).
isMinus(succ(X), pred(Y), succ(succ(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), succ(Y), pred(pred(Z))) :- isMinus(X, Y, Z).
isMinus(pred(X), pred(Y), Z) :- isMinus(X, Y, Z).
isTimes(X, zero, zero).
isTimes(zero, succ(Y), zero).
isTimes(zero, pred(Y), zero).
isTimes(succ(X), succ(Y), Z) :- ','(isTimes(succ(X), Y, A), isPlus(A, succ(X), Z)).
isTimes(succ(X), pred(Y), Z) :- ','(isTimes(succ(X), Y, A), isMinus(A, succ(X), Z)).
isTimes(pred(X), succ(Y), Z) :- ','(isTimes(pred(X), Y, A), isPlus(A, pred(X), Z)).
isTimes(pred(X), pred(Y), Z) :- ','(isTimes(pred(X), Y, A), isMinus(A, pred(X), Z)).
isDiv(zero, succ(Y), zero).
isDiv(zero, pred(Y), zero).
isDiv(succ(X), succ(Y), zero) :- isMinus(succ(X), succ(Y), pred(Z)).
isDiv(succ(X), succ(Y), succ(Z)) :- ','(isMinus(succ(X), succ(Y), A), isDiv(A, succ(Y), Z)).
isDiv(succ(X), pred(Y), Z) :- ','(isMinus(zero, pred(Y), A), ','(isDiv(succ(X), A, B), isMinus(zero, B, Z))).
isDiv(pred(X), pred(Y), zero) :- isMinus(pred(X), pred(Y), succ(Z)).
isDiv(pred(X), pred(Y), succ(Z)) :- ','(isMinus(pred(X), pred(Y), A), isDiv(A, pred(Y), Z)).
isDiv(pred(X), succ(Y), Z) :- ','(isMinus(zero, pred(X), A), ','(isDiv(A, succ(Y), B), isMinus(zero, B, Z))).
isModulo(X, Y, Z) :- ','(isDiv(X, Y, A), ','(isTimes(A, Y, B), isMinus(X, B, Z))).
isLess(pred(X), zero).
isLess(pred(X), succ(Y)).
isLess(pred(X), pred(Y)) :- isLess(X, Y).
isLess(zero, succ(Y)).
isLess(succ(X), succ(Y)) :- isLess(X, Y).
not(X, Y) :- ','(call1(X, Y), fail).
not(X, Y).
call1(X, Y) :- =(X, Y).
fail :- failure(a).
failure(b).
=(X, X).


Query: main(g,a)
----------------------------------------

(13) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

main_in_2: (b,f)

twoWay_in_3: (b,b,f)

isLess_in_2: (b,b)

isMinus_in_3: (b,b,f) (b,b,b)

isTimes_in_3: (b,b,b) (b,b,f)

isPlus_in_3: (b,b,f) (b,b,b)

nounify_in_2: (b,b)

not_in_2: (b,b)

call1_in_2: (b,b)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



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

(14)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)



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

(15) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(succ(zero), X, Ret)
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> U2_GGA(Terminate, N, =_in_ag(X, N))
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> =_IN_AG(X, N)
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> U3_GGA(Terminate, N, X, =_in_ag(X1, zero))
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> =_IN_AG(X1, zero)
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> U4_GGA(Terminate, N, isLess_in_gg(X, X1))
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> ISLESS_IN_GG(X, X1)
   ISLESS_IN_GG(pred(X), pred(Y)) -> U53_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(succ(X), succ(Y)) -> U54_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =_IN_AG(X, Terminate)
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> =_IN_AG(X1, succ(zero))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> =_IN_GG(X, X1)
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> ISMINUS_IN_GGA(N, succ(zero), U)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> U24_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> U25_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> U26_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> U27_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> U30_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> U30_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> U32_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> U34_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> U36_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGA(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGA(A, pred(X), Z)
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGA(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGA(A, pred(X), Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> U20_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> U21_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> U22_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> U23_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGA(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGA(A, succ(X), Z)
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGA(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGA(A, succ(X), Z)
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGG(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGG(A, succ(X), Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> U20_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> U21_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> U22_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> U23_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> U32_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGG(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGG(A, succ(X), Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> U24_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> U25_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> U26_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> U27_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> U28_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> U29_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> U34_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGG(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGG(A, pred(X), Z)
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> U36_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGG(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGG(A, pred(X), Z)
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> NOUNIFY_IN_GG(X, X1)
   NOUNIFY_IN_GG(X, Y) -> U19_GG(X, Y, not_in_gg(X, Y))
   NOUNIFY_IN_GG(X, Y) -> NOT_IN_GG(X, Y)
   NOT_IN_GG(X, Y) -> U55_GG(X, Y, call1_in_gg(X, Y))
   NOT_IN_GG(X, Y) -> CALL1_IN_GG(X, Y)
   CALL1_IN_GG(X, Y) -> U57_GG(X, Y, =_in_gg(X, Y))
   CALL1_IN_GG(X, Y) -> =_IN_GG(X, Y)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> U56_GG(X, Y, fail_in_)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> FAIL_IN_
   FAIL_IN_ -> U58_^1(failure_in_g(a))
   FAIL_IN_ -> FAILURE_IN_G(a)
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> ISPLUS_IN_GGA(N, succ(zero), U)
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x1, x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x1, x2, x3)

=_IN_AG(x1, x2)  =  =_IN_AG(x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x2, x3, x4)

U4_GGA(x1, x2, x3)  =  U4_GGA(x1, x2, x3)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)

U53_GG(x1, x2, x3)  =  U53_GG(x1, x2, x3)

U54_GG(x1, x2, x3)  =  U54_GG(x1, x2, x3)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

=_IN_GG(x1, x2)  =  =_IN_GG(x1, x2)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x2, x6)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)

U24_GGA(x1, x2, x3)  =  U24_GGA(x1, x3)

U25_GGA(x1, x2, x3)  =  U25_GGA(x1, x3)

U26_GGA(x1, x2, x3, x4)  =  U26_GGA(x1, x2, x4)

U27_GGA(x1, x2, x3, x4)  =  U27_GGA(x1, x2, x4)

U28_GGA(x1, x2, x3, x4)  =  U28_GGA(x1, x2, x4)

U29_GGA(x1, x2, x3, x4)  =  U29_GGA(x1, x2, x4)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x2, x6, x7)

U10_GGA(x1, x2, x3, x4, x5, x6)  =  U10_GGA(x1, x2, x4, x5, x6)

U11_GGA(x1, x2, x3, x4, x5)  =  U11_GGA(x1, x2, x4, x5)

ISTIMES_IN_GGG(x1, x2, x3)  =  ISTIMES_IN_GGG(x1, x2, x3)

U30_GGG(x1, x2, x3, x4)  =  U30_GGG(x1, x2, x3, x4)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)

U30_GGA(x1, x2, x3, x4)  =  U30_GGA(x1, x2, x4)

U32_GGA(x1, x2, x3, x4)  =  U32_GGA(x1, x2, x4)

U34_GGA(x1, x2, x3, x4)  =  U34_GGA(x1, x2, x4)

U36_GGA(x1, x2, x3, x4)  =  U36_GGA(x1, x2, x4)

U37_GGA(x1, x2, x3, x4)  =  U37_GGA(x1, x2, x4)

U35_GGA(x1, x2, x3, x4)  =  U35_GGA(x1, x2, x4)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)

U20_GGA(x1, x2, x3, x4)  =  U20_GGA(x1, x2, x4)

U21_GGA(x1, x2, x3, x4)  =  U21_GGA(x1, x2, x4)

U22_GGA(x1, x2, x3, x4)  =  U22_GGA(x1, x2, x4)

U23_GGA(x1, x2, x3, x4)  =  U23_GGA(x1, x2, x4)

U33_GGA(x1, x2, x3, x4)  =  U33_GGA(x1, x2, x4)

U31_GGA(x1, x2, x3, x4)  =  U31_GGA(x1, x2, x4)

U31_GGG(x1, x2, x3, x4)  =  U31_GGG(x1, x2, x3, x4)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)

U20_GGG(x1, x2, x3, x4)  =  U20_GGG(x1, x2, x3, x4)

U21_GGG(x1, x2, x3, x4)  =  U21_GGG(x1, x2, x3, x4)

U22_GGG(x1, x2, x3, x4)  =  U22_GGG(x1, x2, x3, x4)

U23_GGG(x1, x2, x3, x4)  =  U23_GGG(x1, x2, x3, x4)

U32_GGG(x1, x2, x3, x4)  =  U32_GGG(x1, x2, x3, x4)

U33_GGG(x1, x2, x3, x4)  =  U33_GGG(x1, x2, x3, x4)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)

U24_GGG(x1, x2, x3)  =  U24_GGG(x1, x2, x3)

U25_GGG(x1, x2, x3)  =  U25_GGG(x1, x2, x3)

U26_GGG(x1, x2, x3, x4)  =  U26_GGG(x1, x2, x3, x4)

U27_GGG(x1, x2, x3, x4)  =  U27_GGG(x1, x2, x3, x4)

U28_GGG(x1, x2, x3, x4)  =  U28_GGG(x1, x2, x3, x4)

U29_GGG(x1, x2, x3, x4)  =  U29_GGG(x1, x2, x3, x4)

U34_GGG(x1, x2, x3, x4)  =  U34_GGG(x1, x2, x3, x4)

U35_GGG(x1, x2, x3, x4)  =  U35_GGG(x1, x2, x3, x4)

U36_GGG(x1, x2, x3, x4)  =  U36_GGG(x1, x2, x3, x4)

U37_GGG(x1, x2, x3, x4)  =  U37_GGG(x1, x2, x3, x4)

U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x1, x2, x4)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

NOUNIFY_IN_GG(x1, x2)  =  NOUNIFY_IN_GG(x1, x2)

U19_GG(x1, x2, x3)  =  U19_GG(x1, x2, x3)

NOT_IN_GG(x1, x2)  =  NOT_IN_GG(x1, x2)

U55_GG(x1, x2, x3)  =  U55_GG(x1, x2, x3)

CALL1_IN_GG(x1, x2)  =  CALL1_IN_GG(x1, x2)

U57_GG(x1, x2, x3)  =  U57_GG(x1, x2, x3)

U56_GG(x1, x2, x3)  =  U56_GG(x1, x2, x3)

FAIL_IN_  =  FAIL_IN_

U58_^1(x1)  =  U58_^1(x1)

FAILURE_IN_G(x1)  =  FAILURE_IN_G(x1)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x2, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x2, x6, x7)

U16_GGA(x1, x2, x3, x4, x5, x6)  =  U16_GGA(x1, x2, x4, x5, x6)

U17_GGA(x1, x2, x3, x4, x5)  =  U17_GGA(x1, x2, x4, x5)

U18_GGA(x1, x2, x3, x4)  =  U18_GGA(x1, x2, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(16)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(succ(zero), X, Ret)
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> U2_GGA(Terminate, N, =_in_ag(X, N))
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> =_IN_AG(X, N)
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> U3_GGA(Terminate, N, X, =_in_ag(X1, zero))
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> =_IN_AG(X1, zero)
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> U4_GGA(Terminate, N, isLess_in_gg(X, X1))
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> ISLESS_IN_GG(X, X1)
   ISLESS_IN_GG(pred(X), pred(Y)) -> U53_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(succ(X), succ(Y)) -> U54_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =_IN_AG(X, Terminate)
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> =_IN_AG(X1, succ(zero))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> =_IN_GG(X, X1)
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> ISMINUS_IN_GGA(N, succ(zero), U)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> U24_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> U25_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> U26_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> U27_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> U30_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> U30_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> U32_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> U34_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> U36_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGA(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGA(A, pred(X), Z)
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGA(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGA(A, pred(X), Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> U20_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> U21_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> U22_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> U23_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGA(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGA(A, succ(X), Z)
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGA(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGA(A, succ(X), Z)
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGG(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGG(A, succ(X), Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> U20_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> U21_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> U22_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> U23_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> U32_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGG(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGG(A, succ(X), Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> U24_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> U25_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> U26_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> U27_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> U28_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> U29_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> U34_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGG(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGG(A, pred(X), Z)
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> U36_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGG(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGG(A, pred(X), Z)
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> NOUNIFY_IN_GG(X, X1)
   NOUNIFY_IN_GG(X, Y) -> U19_GG(X, Y, not_in_gg(X, Y))
   NOUNIFY_IN_GG(X, Y) -> NOT_IN_GG(X, Y)
   NOT_IN_GG(X, Y) -> U55_GG(X, Y, call1_in_gg(X, Y))
   NOT_IN_GG(X, Y) -> CALL1_IN_GG(X, Y)
   CALL1_IN_GG(X, Y) -> U57_GG(X, Y, =_in_gg(X, Y))
   CALL1_IN_GG(X, Y) -> =_IN_GG(X, Y)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> U56_GG(X, Y, fail_in_)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> FAIL_IN_
   FAIL_IN_ -> U58_^1(failure_in_g(a))
   FAIL_IN_ -> FAILURE_IN_G(a)
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> ISPLUS_IN_GGA(N, succ(zero), U)
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x1, x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x1, x2, x3)

=_IN_AG(x1, x2)  =  =_IN_AG(x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x2, x3, x4)

U4_GGA(x1, x2, x3)  =  U4_GGA(x1, x2, x3)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)

U53_GG(x1, x2, x3)  =  U53_GG(x1, x2, x3)

U54_GG(x1, x2, x3)  =  U54_GG(x1, x2, x3)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

=_IN_GG(x1, x2)  =  =_IN_GG(x1, x2)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x2, x6)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)

U24_GGA(x1, x2, x3)  =  U24_GGA(x1, x3)

U25_GGA(x1, x2, x3)  =  U25_GGA(x1, x3)

U26_GGA(x1, x2, x3, x4)  =  U26_GGA(x1, x2, x4)

U27_GGA(x1, x2, x3, x4)  =  U27_GGA(x1, x2, x4)

U28_GGA(x1, x2, x3, x4)  =  U28_GGA(x1, x2, x4)

U29_GGA(x1, x2, x3, x4)  =  U29_GGA(x1, x2, x4)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x2, x6, x7)

U10_GGA(x1, x2, x3, x4, x5, x6)  =  U10_GGA(x1, x2, x4, x5, x6)

U11_GGA(x1, x2, x3, x4, x5)  =  U11_GGA(x1, x2, x4, x5)

ISTIMES_IN_GGG(x1, x2, x3)  =  ISTIMES_IN_GGG(x1, x2, x3)

U30_GGG(x1, x2, x3, x4)  =  U30_GGG(x1, x2, x3, x4)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)

U30_GGA(x1, x2, x3, x4)  =  U30_GGA(x1, x2, x4)

U32_GGA(x1, x2, x3, x4)  =  U32_GGA(x1, x2, x4)

U34_GGA(x1, x2, x3, x4)  =  U34_GGA(x1, x2, x4)

U36_GGA(x1, x2, x3, x4)  =  U36_GGA(x1, x2, x4)

U37_GGA(x1, x2, x3, x4)  =  U37_GGA(x1, x2, x4)

U35_GGA(x1, x2, x3, x4)  =  U35_GGA(x1, x2, x4)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)

U20_GGA(x1, x2, x3, x4)  =  U20_GGA(x1, x2, x4)

U21_GGA(x1, x2, x3, x4)  =  U21_GGA(x1, x2, x4)

U22_GGA(x1, x2, x3, x4)  =  U22_GGA(x1, x2, x4)

U23_GGA(x1, x2, x3, x4)  =  U23_GGA(x1, x2, x4)

U33_GGA(x1, x2, x3, x4)  =  U33_GGA(x1, x2, x4)

U31_GGA(x1, x2, x3, x4)  =  U31_GGA(x1, x2, x4)

U31_GGG(x1, x2, x3, x4)  =  U31_GGG(x1, x2, x3, x4)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)

U20_GGG(x1, x2, x3, x4)  =  U20_GGG(x1, x2, x3, x4)

U21_GGG(x1, x2, x3, x4)  =  U21_GGG(x1, x2, x3, x4)

U22_GGG(x1, x2, x3, x4)  =  U22_GGG(x1, x2, x3, x4)

U23_GGG(x1, x2, x3, x4)  =  U23_GGG(x1, x2, x3, x4)

U32_GGG(x1, x2, x3, x4)  =  U32_GGG(x1, x2, x3, x4)

U33_GGG(x1, x2, x3, x4)  =  U33_GGG(x1, x2, x3, x4)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)

U24_GGG(x1, x2, x3)  =  U24_GGG(x1, x2, x3)

U25_GGG(x1, x2, x3)  =  U25_GGG(x1, x2, x3)

U26_GGG(x1, x2, x3, x4)  =  U26_GGG(x1, x2, x3, x4)

U27_GGG(x1, x2, x3, x4)  =  U27_GGG(x1, x2, x3, x4)

U28_GGG(x1, x2, x3, x4)  =  U28_GGG(x1, x2, x3, x4)

U29_GGG(x1, x2, x3, x4)  =  U29_GGG(x1, x2, x3, x4)

U34_GGG(x1, x2, x3, x4)  =  U34_GGG(x1, x2, x3, x4)

U35_GGG(x1, x2, x3, x4)  =  U35_GGG(x1, x2, x3, x4)

U36_GGG(x1, x2, x3, x4)  =  U36_GGG(x1, x2, x3, x4)

U37_GGG(x1, x2, x3, x4)  =  U37_GGG(x1, x2, x3, x4)

U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x1, x2, x4)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

NOUNIFY_IN_GG(x1, x2)  =  NOUNIFY_IN_GG(x1, x2)

U19_GG(x1, x2, x3)  =  U19_GG(x1, x2, x3)

NOT_IN_GG(x1, x2)  =  NOT_IN_GG(x1, x2)

U55_GG(x1, x2, x3)  =  U55_GG(x1, x2, x3)

CALL1_IN_GG(x1, x2)  =  CALL1_IN_GG(x1, x2)

U57_GG(x1, x2, x3)  =  U57_GG(x1, x2, x3)

U56_GG(x1, x2, x3)  =  U56_GG(x1, x2, x3)

FAIL_IN_  =  FAIL_IN_

U58_^1(x1)  =  U58_^1(x1)

FAILURE_IN_G(x1)  =  FAILURE_IN_G(x1)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x2, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x2, x6, x7)

U16_GGA(x1, x2, x3, x4, x5, x6)  =  U16_GGA(x1, x2, x4, x5, x6)

U17_GGA(x1, x2, x3, x4, x5)  =  U17_GGA(x1, x2, x4, x5)

U18_GGA(x1, x2, x3, x4)  =  U18_GGA(x1, x2, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(17) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 10 SCCs with 86 less nodes.
----------------------------------------

(18)
Complex Obligation (AND)

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

(19)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(20) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(21)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(22) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(23)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(24) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
The graph contains the following edges 1 >= 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
The graph contains the following edges 1 >= 1, 2 > 2, 3 > 3


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

(25)
YES

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

(26)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(27) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(28)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(29) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(30)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(31) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


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

(32)
YES

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

(33)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(34) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(35)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(36) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(37)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(38) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


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

(39)
YES

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

(40)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(41) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(42)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(43) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(44)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(succ(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(pred(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(pred(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(45) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISPLUS_IN_GGA(succ(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(succ(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(pred(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(pred(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(46)
YES

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

(47)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(48) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(49)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
zero  =  zero

pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(50) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(51)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y)) -> ISMINUS_IN_GGA(zero, Y)
   ISMINUS_IN_GGA(zero, succ(Y)) -> ISMINUS_IN_GGA(zero, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(52) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGA(zero, pred(Y)) -> ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISMINUS_IN_GGA(zero, succ(Y)) -> ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(53)
YES

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

(54)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(55) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(56)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(57) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(58)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(succ(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(pred(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(pred(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(59) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGA(succ(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(succ(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(pred(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(pred(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(60)
YES

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

(61)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(62) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(63)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(64) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(65)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
   ISTIMES_IN_GGA(succ(X), succ(Y)) -> ISTIMES_IN_GGA(succ(X), Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(66) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISTIMES_IN_GGA(succ(X), pred(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISTIMES_IN_GGA(succ(X), succ(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(67)
YES

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

(68)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(69) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(70)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(71) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(72)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
   ISTIMES_IN_GGA(pred(X), succ(Y)) -> ISTIMES_IN_GGA(pred(X), Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(73) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISTIMES_IN_GGA(pred(X), pred(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISTIMES_IN_GGA(pred(X), succ(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(74)
YES

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

(75)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(76) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(77)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(78) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(79)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(80) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(81)
YES

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

(82)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x1, x2, x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg(x1, x2)

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x1, x2, x3)

U54_gg(x1, x2, x3)  =  U54_gg(x1, x2, x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2, x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x2, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x2, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x1, x2, x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x1, x2, x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg(x1, x2, x3)

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x2, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x1, x2, x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x2, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x2, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x2, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x2, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x1, x2, x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x1, x2, x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x1, x2, x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x1, x2, x3, x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg(x1, x2, x3)

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x1, x2, x3, x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x1, x2, x3, x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x1, x2, x3, x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x1, x2, x3, x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x2, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x1, x2, x3, x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg(x1, x2, x3)

U24_ggg(x1, x2, x3)  =  U24_ggg(x1, x2, x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x1, x2, x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x1, x2, x3, x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x1, x2, x3, x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x1, x2, x3, x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x1, x2, x3, x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x2, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x1, x2, x3, x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x2, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x1, x2, x3, x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x1, x2, x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x2, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x2, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x1, x2, x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x1, x2, x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1, x2)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x2, x6)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x2, x6, x7)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x2, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x2, x6, x7)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(83) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(84)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   =_in_ag(X, X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The argument filtering Pi contains the following mapping:
=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1, x2)

zero  =  zero

pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg(x1, x2)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x1, x2, x3)

U24_gga(x1, x2, x3)  =  U24_gga(x1, x3)

U25_gga(x1, x2, x3)  =  U25_gga(x1, x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x1, x2, x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x1, x2, x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x1, x2, x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x1, x2, x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x1, x2, x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x1, x2, x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x1, x2, x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x1, x2, x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x1, x2, x4)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x1, x2, x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x1, x2, x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x1, x2, x3)

call1_out_gg(x1, x2)  =  call1_out_gg(x1, x2)

U56_gg(x1, x2, x3)  =  U56_gg(x1, x2, x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg(x1, x2)

nounify_out_gg(x1, x2)  =  nounify_out_gg(x1, x2)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x2, x6)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x2, x6, x7)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x2, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x2, x6, x7)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(85) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(86)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_in_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero)))
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_in_ag(U))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_in_ag(U))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(87) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_in_ag(Terminate)) at position [2] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate)),TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate)))


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

(88)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero)))
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_in_ag(U))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_in_ag(U))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(89) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero))) at position [3] we obtained the following new rules [LPAR04]:

   (U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero))),U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero))))


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

(90)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_in_ag(U))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_in_ag(U))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(91) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_in_ag(U)) at position [3] we obtained the following new rules [LPAR04]:

   (U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U)),U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U)))


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

(92)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_in_ag(U))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(93) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_in_ag(U)) at position [3] we obtained the following new rules [LPAR04]:

   (U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U)),U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U)))


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

(94)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(95) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(96)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(97) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =_in_ag(x0)


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

(98)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(99) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, =_in_gg(X, X1)) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0)),U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0)))


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

(100)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(101) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(Terminate, N, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1)) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1))),U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1))))


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

(102)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(103) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(104)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(105) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   nounify_in_gg(x0, x1)


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

(106)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(107) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_in_gg(x0, x1))) at position [2,2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1)))),U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1)))))
   (U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1))),U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1))))


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

(108)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(109) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(110)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))

The TRS R consists of the following rules:

   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   not_in_gg(x0, x1)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(111) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   not_in_gg(x0, x1)


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

(112)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))

The TRS R consists of the following rules:

   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(113) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, call1_in_gg(x0, x1)))) at position [2,2,2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1))))),U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1))))))


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

(114)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(115) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(116)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   call1_in_gg(x0, x1)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(117) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   call1_in_gg(x0, x1)


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

(118)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1)))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(119) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, not_out_gg(x0, x1))) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1)),U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1)))


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

(120)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1)))))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(121) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x1, U55_gg(x0, x1, U57_gg(x0, x1, =_in_gg(x0, x1))))) at position [2,2,2,2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0))))),U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0))))))


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

(122)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0)))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg(X, X)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(123) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(124)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0)))))

The TRS R consists of the following rules:

   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(125) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =_in_gg(x0, x1)


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

(126)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0)))))

The TRS R consists of the following rules:

   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(127) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, U57_gg(x0, x0, =_out_gg(x0, x0))))) at position [2,2,2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, call1_out_gg(x0, x0)))),U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, call1_out_gg(x0, x0)))))


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

(128)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, call1_out_gg(x0, x0))))

The TRS R consists of the following rules:

   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(129) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(130)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, N, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate, Terminate))
   U5_GGA(Terminate, N, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero), succ(zero)))
   U8_GGA(Terminate, N, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, U, =_out_ag(U, U))
   U14_GGA(Terminate, N, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, U, =_out_ag(U, U))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U7_GGA(y0, y1, =_out_gg(x0, x0))
   U6_GGA(y0, y1, x0, =_out_ag(x1, succ(zero))) -> U13_GGA(y0, y1, nounify_out_gg(x0, x1))
   U6_GGA(y0, y1, x0, =_out_ag(x0, succ(zero))) -> U13_GGA(y0, y1, U19_gg(x0, x0, U55_gg(x0, x0, call1_out_gg(x0, x0))))

The TRS R consists of the following rules:

   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   isPlus_in_gga(zero, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(X, Y, isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(X, Y, isPlus_in_gga(X, Y))
   U22_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U23_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U21_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(Y, isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(X, Y, isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(X, Y, isMinus_in_gga(X, Y))
   U28_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U29_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U27_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U25_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U26_gga(X, Y, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U24_gga(Y, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0, x1)
   U26_gga(x0, x1, x2)
   U28_gga(x0, x1, x2)
   U19_gg(x0, x1, x2)
   U20_gga(x0, x1, x2)
   U22_gga(x0, x1, x2)
   U25_gga(x0, x1)
   U27_gga(x0, x1, x2)
   U29_gga(x0, x1, x2)
   U55_gg(x0, x1, x2)
   U21_gga(x0, x1, x2)
   U23_gga(x0, x1, x2)
   U56_gg(x0, x1, x2)
   U57_gg(x0, x1, x2)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(131) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

main_in_2: (b,f)

twoWay_in_3: (b,b,f)

isLess_in_2: (b,b)

isMinus_in_3: (b,b,f) (b,b,b)

isTimes_in_3: (b,b,b) (b,b,f)

isPlus_in_3: (b,b,f) (b,b,b)

nounify_in_2: (b,b)

not_in_2: (b,b)

call1_in_2: (b,b)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



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

(132)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)



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

(133) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(succ(zero), X, Ret)
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> U2_GGA(Terminate, N, =_in_ag(X, N))
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> =_IN_AG(X, N)
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> U3_GGA(Terminate, N, X, =_in_ag(X1, zero))
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> =_IN_AG(X1, zero)
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> U4_GGA(Terminate, N, isLess_in_gg(X, X1))
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> ISLESS_IN_GG(X, X1)
   ISLESS_IN_GG(pred(X), pred(Y)) -> U53_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(succ(X), succ(Y)) -> U54_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =_IN_AG(X, Terminate)
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> =_IN_AG(X1, succ(zero))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> =_IN_GG(X, X1)
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> ISMINUS_IN_GGA(N, succ(zero), U)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> U24_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> U25_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> U26_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> U27_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> U30_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> U30_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> U32_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> U34_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> U36_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGA(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGA(A, pred(X), Z)
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGA(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGA(A, pred(X), Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> U20_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> U21_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> U22_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> U23_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGA(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGA(A, succ(X), Z)
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGA(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGA(A, succ(X), Z)
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGG(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGG(A, succ(X), Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> U20_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> U21_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> U22_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> U23_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> U32_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGG(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGG(A, succ(X), Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> U24_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> U25_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> U26_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> U27_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> U28_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> U29_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> U34_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGG(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGG(A, pred(X), Z)
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> U36_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGG(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGG(A, pred(X), Z)
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> NOUNIFY_IN_GG(X, X1)
   NOUNIFY_IN_GG(X, Y) -> U19_GG(X, Y, not_in_gg(X, Y))
   NOUNIFY_IN_GG(X, Y) -> NOT_IN_GG(X, Y)
   NOT_IN_GG(X, Y) -> U55_GG(X, Y, call1_in_gg(X, Y))
   NOT_IN_GG(X, Y) -> CALL1_IN_GG(X, Y)
   CALL1_IN_GG(X, Y) -> U57_GG(X, Y, =_in_gg(X, Y))
   CALL1_IN_GG(X, Y) -> =_IN_GG(X, Y)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> U56_GG(X, Y, fail_in_)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> FAIL_IN_
   FAIL_IN_ -> U58_^1(failure_in_g(a))
   FAIL_IN_ -> FAILURE_IN_G(a)
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> ISPLUS_IN_GGA(N, succ(zero), U)
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x3)

=_IN_AG(x1, x2)  =  =_IN_AG(x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x3, x4)

U4_GGA(x1, x2, x3)  =  U4_GGA(x3)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)

U53_GG(x1, x2, x3)  =  U53_GG(x3)

U54_GG(x1, x2, x3)  =  U54_GG(x3)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

=_IN_GG(x1, x2)  =  =_IN_GG(x1, x2)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x6)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)

U24_GGA(x1, x2, x3)  =  U24_GGA(x3)

U25_GGA(x1, x2, x3)  =  U25_GGA(x3)

U26_GGA(x1, x2, x3, x4)  =  U26_GGA(x4)

U27_GGA(x1, x2, x3, x4)  =  U27_GGA(x4)

U28_GGA(x1, x2, x3, x4)  =  U28_GGA(x4)

U29_GGA(x1, x2, x3, x4)  =  U29_GGA(x4)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x6, x7)

U10_GGA(x1, x2, x3, x4, x5, x6)  =  U10_GGA(x4, x5, x6)

U11_GGA(x1, x2, x3, x4, x5)  =  U11_GGA(x4, x5)

ISTIMES_IN_GGG(x1, x2, x3)  =  ISTIMES_IN_GGG(x1, x2, x3)

U30_GGG(x1, x2, x3, x4)  =  U30_GGG(x1, x3, x4)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)

U30_GGA(x1, x2, x3, x4)  =  U30_GGA(x1, x4)

U32_GGA(x1, x2, x3, x4)  =  U32_GGA(x1, x4)

U34_GGA(x1, x2, x3, x4)  =  U34_GGA(x1, x4)

U36_GGA(x1, x2, x3, x4)  =  U36_GGA(x1, x4)

U37_GGA(x1, x2, x3, x4)  =  U37_GGA(x4)

U35_GGA(x1, x2, x3, x4)  =  U35_GGA(x4)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)

U20_GGA(x1, x2, x3, x4)  =  U20_GGA(x4)

U21_GGA(x1, x2, x3, x4)  =  U21_GGA(x4)

U22_GGA(x1, x2, x3, x4)  =  U22_GGA(x4)

U23_GGA(x1, x2, x3, x4)  =  U23_GGA(x4)

U33_GGA(x1, x2, x3, x4)  =  U33_GGA(x4)

U31_GGA(x1, x2, x3, x4)  =  U31_GGA(x4)

U31_GGG(x1, x2, x3, x4)  =  U31_GGG(x4)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)

U20_GGG(x1, x2, x3, x4)  =  U20_GGG(x4)

U21_GGG(x1, x2, x3, x4)  =  U21_GGG(x4)

U22_GGG(x1, x2, x3, x4)  =  U22_GGG(x4)

U23_GGG(x1, x2, x3, x4)  =  U23_GGG(x4)

U32_GGG(x1, x2, x3, x4)  =  U32_GGG(x1, x3, x4)

U33_GGG(x1, x2, x3, x4)  =  U33_GGG(x4)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)

U24_GGG(x1, x2, x3)  =  U24_GGG(x3)

U25_GGG(x1, x2, x3)  =  U25_GGG(x3)

U26_GGG(x1, x2, x3, x4)  =  U26_GGG(x4)

U27_GGG(x1, x2, x3, x4)  =  U27_GGG(x4)

U28_GGG(x1, x2, x3, x4)  =  U28_GGG(x4)

U29_GGG(x1, x2, x3, x4)  =  U29_GGG(x4)

U34_GGG(x1, x2, x3, x4)  =  U34_GGG(x1, x3, x4)

U35_GGG(x1, x2, x3, x4)  =  U35_GGG(x4)

U36_GGG(x1, x2, x3, x4)  =  U36_GGG(x1, x3, x4)

U37_GGG(x1, x2, x3, x4)  =  U37_GGG(x4)

U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x4)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

NOUNIFY_IN_GG(x1, x2)  =  NOUNIFY_IN_GG(x1, x2)

U19_GG(x1, x2, x3)  =  U19_GG(x3)

NOT_IN_GG(x1, x2)  =  NOT_IN_GG(x1, x2)

U55_GG(x1, x2, x3)  =  U55_GG(x3)

CALL1_IN_GG(x1, x2)  =  CALL1_IN_GG(x1, x2)

U57_GG(x1, x2, x3)  =  U57_GG(x3)

U56_GG(x1, x2, x3)  =  U56_GG(x3)

FAIL_IN_  =  FAIL_IN_

U58_^1(x1)  =  U58_^1(x1)

FAILURE_IN_G(x1)  =  FAILURE_IN_G(x1)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x6, x7)

U16_GGA(x1, x2, x3, x4, x5, x6)  =  U16_GGA(x4, x5, x6)

U17_GGA(x1, x2, x3, x4, x5)  =  U17_GGA(x4, x5)

U18_GGA(x1, x2, x3, x4)  =  U18_GGA(x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(134)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(succ(zero), X, Ret)
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> U2_GGA(Terminate, N, =_in_ag(X, N))
   TWOWAY_IN_GGA(Terminate, N, succ(zero)) -> =_IN_AG(X, N)
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> U3_GGA(Terminate, N, X, =_in_ag(X1, zero))
   U2_GGA(Terminate, N, =_out_ag(X, N)) -> =_IN_AG(X1, zero)
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> U4_GGA(Terminate, N, isLess_in_gg(X, X1))
   U3_GGA(Terminate, N, X, =_out_ag(X1, zero)) -> ISLESS_IN_GG(X, X1)
   ISLESS_IN_GG(pred(X), pred(Y)) -> U53_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(succ(X), succ(Y)) -> U54_GG(X, Y, isLess_in_gg(X, Y))
   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =_IN_AG(X, Terminate)
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> =_IN_AG(X1, succ(zero))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> =_IN_GG(X, X1)
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> ISMINUS_IN_GGA(N, succ(zero), U)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> U24_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> U25_GGA(Y, Z, isMinus_in_gga(zero, Y, Z))
   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> U26_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> U27_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> U28_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> U29_GGA(X, Y, Z, isMinus_in_gga(X, Y, Z))
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U10_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> U30_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> U30_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> U32_GGA(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> U34_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> U36_GGA(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGA(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U36_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGA(A, pred(X), Z)
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGA(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   U34_GGA(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGA(A, pred(X), Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> U20_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> U21_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> U22_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> U23_GGA(X, Y, Z, isPlus_in_gga(X, Y, Z))
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGA(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U32_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGA(A, succ(X), Z)
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGA(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U30_GGA(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGA(A, succ(X), Z)
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_GGG(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   U30_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISPLUS_IN_GGG(A, succ(X), Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> U20_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> U21_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> U22_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> U23_GGG(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> U32_GGG(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   ISTIMES_IN_GGG(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_GGG(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   U32_GGG(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> ISMINUS_IN_GGG(A, succ(X), Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> U24_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> U25_GGG(Y, Z, isMinus_in_ggg(zero, Y, Z))
   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> U26_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> U27_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> U28_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> U29_GGG(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> U34_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_GGG(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U34_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISPLUS_IN_GGG(A, pred(X), Z)
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> U36_GGG(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   ISTIMES_IN_GGG(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_GGG(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U36_GGG(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> ISMINUS_IN_GGG(A, pred(X), Z)
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U11_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> NOUNIFY_IN_GG(X, X1)
   NOUNIFY_IN_GG(X, Y) -> U19_GG(X, Y, not_in_gg(X, Y))
   NOUNIFY_IN_GG(X, Y) -> NOT_IN_GG(X, Y)
   NOT_IN_GG(X, Y) -> U55_GG(X, Y, call1_in_gg(X, Y))
   NOT_IN_GG(X, Y) -> CALL1_IN_GG(X, Y)
   CALL1_IN_GG(X, Y) -> U57_GG(X, Y, =_in_gg(X, Y))
   CALL1_IN_GG(X, Y) -> =_IN_GG(X, Y)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> U56_GG(X, Y, fail_in_)
   U55_GG(X, Y, call1_out_gg(X, Y)) -> FAIL_IN_
   FAIL_IN_ -> U58_^1(failure_in_g(a))
   FAIL_IN_ -> FAILURE_IN_G(a)
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> ISPLUS_IN_GGA(N, succ(zero), U)
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> =_IN_AG(M, U)
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_GGA(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_GGA(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U16_GGA(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> ISTIMES_IN_GGG(Ret1, M, U)
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_GGA(Terminate, N, Ret, =_in_ag(Ret, U))
   U17_GGA(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> =_IN_AG(Ret, U)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x3)

=_IN_AG(x1, x2)  =  =_IN_AG(x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x3, x4)

U4_GGA(x1, x2, x3)  =  U4_GGA(x3)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)

U53_GG(x1, x2, x3)  =  U53_GG(x3)

U54_GG(x1, x2, x3)  =  U54_GG(x3)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

=_IN_GG(x1, x2)  =  =_IN_GG(x1, x2)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x6)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)

U24_GGA(x1, x2, x3)  =  U24_GGA(x3)

U25_GGA(x1, x2, x3)  =  U25_GGA(x3)

U26_GGA(x1, x2, x3, x4)  =  U26_GGA(x4)

U27_GGA(x1, x2, x3, x4)  =  U27_GGA(x4)

U28_GGA(x1, x2, x3, x4)  =  U28_GGA(x4)

U29_GGA(x1, x2, x3, x4)  =  U29_GGA(x4)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x6, x7)

U10_GGA(x1, x2, x3, x4, x5, x6)  =  U10_GGA(x4, x5, x6)

U11_GGA(x1, x2, x3, x4, x5)  =  U11_GGA(x4, x5)

ISTIMES_IN_GGG(x1, x2, x3)  =  ISTIMES_IN_GGG(x1, x2, x3)

U30_GGG(x1, x2, x3, x4)  =  U30_GGG(x1, x3, x4)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)

U30_GGA(x1, x2, x3, x4)  =  U30_GGA(x1, x4)

U32_GGA(x1, x2, x3, x4)  =  U32_GGA(x1, x4)

U34_GGA(x1, x2, x3, x4)  =  U34_GGA(x1, x4)

U36_GGA(x1, x2, x3, x4)  =  U36_GGA(x1, x4)

U37_GGA(x1, x2, x3, x4)  =  U37_GGA(x4)

U35_GGA(x1, x2, x3, x4)  =  U35_GGA(x4)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)

U20_GGA(x1, x2, x3, x4)  =  U20_GGA(x4)

U21_GGA(x1, x2, x3, x4)  =  U21_GGA(x4)

U22_GGA(x1, x2, x3, x4)  =  U22_GGA(x4)

U23_GGA(x1, x2, x3, x4)  =  U23_GGA(x4)

U33_GGA(x1, x2, x3, x4)  =  U33_GGA(x4)

U31_GGA(x1, x2, x3, x4)  =  U31_GGA(x4)

U31_GGG(x1, x2, x3, x4)  =  U31_GGG(x4)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)

U20_GGG(x1, x2, x3, x4)  =  U20_GGG(x4)

U21_GGG(x1, x2, x3, x4)  =  U21_GGG(x4)

U22_GGG(x1, x2, x3, x4)  =  U22_GGG(x4)

U23_GGG(x1, x2, x3, x4)  =  U23_GGG(x4)

U32_GGG(x1, x2, x3, x4)  =  U32_GGG(x1, x3, x4)

U33_GGG(x1, x2, x3, x4)  =  U33_GGG(x4)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)

U24_GGG(x1, x2, x3)  =  U24_GGG(x3)

U25_GGG(x1, x2, x3)  =  U25_GGG(x3)

U26_GGG(x1, x2, x3, x4)  =  U26_GGG(x4)

U27_GGG(x1, x2, x3, x4)  =  U27_GGG(x4)

U28_GGG(x1, x2, x3, x4)  =  U28_GGG(x4)

U29_GGG(x1, x2, x3, x4)  =  U29_GGG(x4)

U34_GGG(x1, x2, x3, x4)  =  U34_GGG(x1, x3, x4)

U35_GGG(x1, x2, x3, x4)  =  U35_GGG(x4)

U36_GGG(x1, x2, x3, x4)  =  U36_GGG(x1, x3, x4)

U37_GGG(x1, x2, x3, x4)  =  U37_GGG(x4)

U12_GGA(x1, x2, x3, x4)  =  U12_GGA(x4)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

NOUNIFY_IN_GG(x1, x2)  =  NOUNIFY_IN_GG(x1, x2)

U19_GG(x1, x2, x3)  =  U19_GG(x3)

NOT_IN_GG(x1, x2)  =  NOT_IN_GG(x1, x2)

U55_GG(x1, x2, x3)  =  U55_GG(x3)

CALL1_IN_GG(x1, x2)  =  CALL1_IN_GG(x1, x2)

U57_GG(x1, x2, x3)  =  U57_GG(x3)

U56_GG(x1, x2, x3)  =  U56_GG(x3)

FAIL_IN_  =  FAIL_IN_

U58_^1(x1)  =  U58_^1(x1)

FAILURE_IN_G(x1)  =  FAILURE_IN_G(x1)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x6, x7)

U16_GGA(x1, x2, x3, x4, x5, x6)  =  U16_GGA(x4, x5, x6)

U17_GGA(x1, x2, x3, x4, x5)  =  U17_GGA(x4, x5)

U18_GGA(x1, x2, x3, x4)  =  U18_GGA(x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(135) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 10 SCCs with 86 less nodes.
----------------------------------------

(136)
Complex Obligation (AND)

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

(137)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(138) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(139)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(140) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(141)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
   ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(142) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGG(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
The graph contains the following edges 1 >= 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGG(zero, Y, Z)
The graph contains the following edges 1 >= 1, 2 > 2, 3 > 3


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

(143)
YES

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

(144)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISMINUS_IN_GGG(x1, x2, x3)  =  ISMINUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(145) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(146)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(147) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(148)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
   ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(149) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGG(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(succ(X), succ(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISMINUS_IN_GGG(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISMINUS_IN_GGG(pred(X), pred(Y), Z) -> ISMINUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


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

(150)
YES

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

(151)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISPLUS_IN_GGG(x1, x2, x3)  =  ISPLUS_IN_GGG(x1, x2, x3)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(152) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(153)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(154) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(155)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
   ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(156) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISPLUS_IN_GGG(succ(X), pred(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISPLUS_IN_GGG(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


*ISPLUS_IN_GGG(pred(X), succ(Y), Z) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 >= 3


*ISPLUS_IN_GGG(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGG(X, Y, Z)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3


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

(157)
YES

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

(158)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(159) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(160)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(succ(X), succ(Y), succ(succ(Z))) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), succ(Y), Z) -> ISPLUS_IN_GGA(X, Y, Z)
   ISPLUS_IN_GGA(pred(X), pred(Y), pred(pred(Z))) -> ISPLUS_IN_GGA(X, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISPLUS_IN_GGA(x1, x2, x3)  =  ISPLUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(161) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(162)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISPLUS_IN_GGA(succ(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(succ(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(pred(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
   ISPLUS_IN_GGA(pred(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(163) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISPLUS_IN_GGA(succ(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(succ(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(pred(X), succ(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISPLUS_IN_GGA(pred(X), pred(Y)) -> ISPLUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(164)
YES

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

(165)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(166) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(167)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y), succ(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)
   ISMINUS_IN_GGA(zero, succ(Y), pred(Z)) -> ISMINUS_IN_GGA(zero, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
zero  =  zero

pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(168) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(169)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(zero, pred(Y)) -> ISMINUS_IN_GGA(zero, Y)
   ISMINUS_IN_GGA(zero, succ(Y)) -> ISMINUS_IN_GGA(zero, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(170) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGA(zero, pred(Y)) -> ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISMINUS_IN_GGA(zero, succ(Y)) -> ISMINUS_IN_GGA(zero, Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(171)
YES

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

(172)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(173) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(174)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y), succ(succ(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(succ(X), succ(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), succ(Y), pred(pred(Z))) -> ISMINUS_IN_GGA(X, Y, Z)
   ISMINUS_IN_GGA(pred(X), pred(Y), Z) -> ISMINUS_IN_GGA(X, Y, Z)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISMINUS_IN_GGA(x1, x2, x3)  =  ISMINUS_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(175) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(176)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISMINUS_IN_GGA(succ(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(succ(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(pred(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
   ISMINUS_IN_GGA(pred(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(177) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISMINUS_IN_GGA(succ(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(succ(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(pred(X), succ(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISMINUS_IN_GGA(pred(X), pred(Y)) -> ISMINUS_IN_GGA(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(178)
YES

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

(179)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(180) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(181)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)
   ISTIMES_IN_GGA(succ(X), succ(Y), Z) -> ISTIMES_IN_GGA(succ(X), Y, A)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(182) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(183)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(succ(X), pred(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
   ISTIMES_IN_GGA(succ(X), succ(Y)) -> ISTIMES_IN_GGA(succ(X), Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(184) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISTIMES_IN_GGA(succ(X), pred(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISTIMES_IN_GGA(succ(X), succ(Y)) -> ISTIMES_IN_GGA(succ(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(185)
YES

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

(186)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(187) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(188)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)
   ISTIMES_IN_GGA(pred(X), succ(Y), Z) -> ISTIMES_IN_GGA(pred(X), Y, A)

R is empty.
The argument filtering Pi contains the following mapping:
pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

ISTIMES_IN_GGA(x1, x2, x3)  =  ISTIMES_IN_GGA(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(189) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(190)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISTIMES_IN_GGA(pred(X), pred(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
   ISTIMES_IN_GGA(pred(X), succ(Y)) -> ISTIMES_IN_GGA(pred(X), Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(191) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISTIMES_IN_GGA(pred(X), pred(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


*ISTIMES_IN_GGA(pred(X), succ(Y)) -> ISTIMES_IN_GGA(pred(X), Y)
The graph contains the following edges 1 >= 1, 2 > 2


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

(192)
YES

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

(193)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

ISLESS_IN_GG(x1, x2)  =  ISLESS_IN_GG(x1, x2)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(194) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(195)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

R is empty.
Pi is empty.
We have to consider all (P,R,Pi)-chains
----------------------------------------

(196) PiDPToQDPProof (EQUIVALENT)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(197)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
   ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(198) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*ISLESS_IN_GG(succ(X), succ(Y)) -> ISLESS_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


*ISLESS_IN_GG(pred(X), pred(Y)) -> ISLESS_IN_GG(X, Y)
The graph contains the following edges 1 > 1, 2 > 2


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

(199)
YES

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

(200)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(succ(zero), X, Ret))
   twoWay_in_gga(Terminate, N, succ(zero)) -> U2_gga(Terminate, N, =_in_ag(X, N))
   =_in_ag(X, X) -> =_out_ag(X, X)
   U2_gga(Terminate, N, =_out_ag(X, N)) -> U3_gga(Terminate, N, X, =_in_ag(X1, zero))
   U3_gga(Terminate, N, X, =_out_ag(X1, zero)) -> U4_gga(Terminate, N, isLess_in_gg(X, X1))
   isLess_in_gg(pred(X), zero) -> isLess_out_gg(pred(X), zero)
   isLess_in_gg(pred(X), succ(Y)) -> isLess_out_gg(pred(X), succ(Y))
   isLess_in_gg(pred(X), pred(Y)) -> U53_gg(X, Y, isLess_in_gg(X, Y))
   isLess_in_gg(zero, succ(Y)) -> isLess_out_gg(zero, succ(Y))
   isLess_in_gg(succ(X), succ(Y)) -> U54_gg(X, Y, isLess_in_gg(X, Y))
   U54_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(succ(X), succ(Y))
   U53_gg(X, Y, isLess_out_gg(X, Y)) -> isLess_out_gg(pred(X), pred(Y))
   U4_gga(Terminate, N, isLess_out_gg(X, X1)) -> twoWay_out_gga(Terminate, N, succ(zero))
   twoWay_in_gga(Terminate, N, Ret) -> U5_gga(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_gga(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_gga(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_gga(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   =_in_gg(X, X) -> =_out_gg(X, X)
   U7_gga(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_gga(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U8_gga(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U10_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U10_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U11_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   isTimes_in_ggg(X, zero, zero) -> isTimes_out_ggg(X, zero, zero)
   isTimes_in_ggg(zero, succ(Y), zero) -> isTimes_out_ggg(zero, succ(Y), zero)
   isTimes_in_ggg(zero, pred(Y), zero) -> isTimes_out_ggg(zero, pred(Y), zero)
   isTimes_in_ggg(succ(X), succ(Y), Z) -> U30_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(X, zero, zero) -> isTimes_out_gga(X, zero, zero)
   isTimes_in_gga(zero, succ(Y), zero) -> isTimes_out_gga(zero, succ(Y), zero)
   isTimes_in_gga(zero, pred(Y), zero) -> isTimes_out_gga(zero, pred(Y), zero)
   isTimes_in_gga(succ(X), succ(Y), Z) -> U30_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(succ(X), pred(Y), Z) -> U32_gga(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   isTimes_in_gga(pred(X), succ(Y), Z) -> U34_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   isTimes_in_gga(pred(X), pred(Y), Z) -> U36_gga(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_gga(X, Y, Z, isMinus_in_gga(A, pred(X), Z))
   U37_gga(X, Y, Z, isMinus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), pred(Y), Z)
   U34_gga(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_gga(X, Y, Z, isPlus_in_gga(A, pred(X), Z))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U35_gga(X, Y, Z, isPlus_out_gga(A, pred(X), Z)) -> isTimes_out_gga(pred(X), succ(Y), Z)
   U32_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_gga(X, Y, Z, isMinus_in_gga(A, succ(X), Z))
   U33_gga(X, Y, Z, isMinus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), pred(Y), Z)
   U30_gga(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_gga(X, Y, Z, isPlus_in_gga(A, succ(X), Z))
   U31_gga(X, Y, Z, isPlus_out_gga(A, succ(X), Z)) -> isTimes_out_gga(succ(X), succ(Y), Z)
   U30_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U31_ggg(X, Y, Z, isPlus_in_ggg(A, succ(X), Z))
   isPlus_in_ggg(zero, X, X) -> isPlus_out_ggg(zero, X, X)
   isPlus_in_ggg(succ(X), zero, succ(X)) -> isPlus_out_ggg(succ(X), zero, succ(X))
   isPlus_in_ggg(succ(X), succ(Y), succ(succ(Z))) -> U20_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(succ(X), pred(Y), Z) -> U21_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), zero, pred(X)) -> isPlus_out_ggg(pred(X), zero, pred(X))
   isPlus_in_ggg(pred(X), succ(Y), Z) -> U22_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   isPlus_in_ggg(pred(X), pred(Y), pred(pred(Z))) -> U23_ggg(X, Y, Z, isPlus_in_ggg(X, Y, Z))
   U23_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), pred(Y), pred(pred(Z)))
   U22_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(pred(X), succ(Y), Z)
   U21_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), pred(Y), Z)
   U20_ggg(X, Y, Z, isPlus_out_ggg(X, Y, Z)) -> isPlus_out_ggg(succ(X), succ(Y), succ(succ(Z)))
   U31_ggg(X, Y, Z, isPlus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), succ(Y), Z)
   isTimes_in_ggg(succ(X), pred(Y), Z) -> U32_ggg(X, Y, Z, isTimes_in_gga(succ(X), Y, A))
   U32_ggg(X, Y, Z, isTimes_out_gga(succ(X), Y, A)) -> U33_ggg(X, Y, Z, isMinus_in_ggg(A, succ(X), Z))
   isMinus_in_ggg(X, zero, X) -> isMinus_out_ggg(X, zero, X)
   isMinus_in_ggg(zero, succ(Y), pred(Z)) -> U24_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(zero, pred(Y), succ(Z)) -> U25_ggg(Y, Z, isMinus_in_ggg(zero, Y, Z))
   isMinus_in_ggg(succ(X), succ(Y), Z) -> U26_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(succ(X), pred(Y), succ(succ(Z))) -> U27_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), succ(Y), pred(pred(Z))) -> U28_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   isMinus_in_ggg(pred(X), pred(Y), Z) -> U29_ggg(X, Y, Z, isMinus_in_ggg(X, Y, Z))
   U29_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), pred(Y), Z)
   U28_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(pred(X), succ(Y), pred(pred(Z)))
   U27_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), pred(Y), succ(succ(Z)))
   U26_ggg(X, Y, Z, isMinus_out_ggg(X, Y, Z)) -> isMinus_out_ggg(succ(X), succ(Y), Z)
   U25_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, pred(Y), succ(Z))
   U24_ggg(Y, Z, isMinus_out_ggg(zero, Y, Z)) -> isMinus_out_ggg(zero, succ(Y), pred(Z))
   U33_ggg(X, Y, Z, isMinus_out_ggg(A, succ(X), Z)) -> isTimes_out_ggg(succ(X), pred(Y), Z)
   isTimes_in_ggg(pred(X), succ(Y), Z) -> U34_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U34_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U35_ggg(X, Y, Z, isPlus_in_ggg(A, pred(X), Z))
   U35_ggg(X, Y, Z, isPlus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), succ(Y), Z)
   isTimes_in_ggg(pred(X), pred(Y), Z) -> U36_ggg(X, Y, Z, isTimes_in_gga(pred(X), Y, A))
   U36_ggg(X, Y, Z, isTimes_out_gga(pred(X), Y, A)) -> U37_ggg(X, Y, Z, isMinus_in_ggg(A, pred(X), Z))
   U37_ggg(X, Y, Z, isMinus_out_ggg(A, pred(X), Z)) -> isTimes_out_ggg(pred(X), pred(Y), Z)
   U11_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U12_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U12_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U6_gga(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_gga(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   failure_in_g(b) -> failure_out_g(b)
   U58_(failure_out_g(a)) -> fail_out_
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U13_gga(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_gga(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_gga(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_gga(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_gga(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> U16_gga(Terminate, N, Ret, U, M, twoWay_in_gga(Terminate, M, Ret1))
   U16_gga(Terminate, N, Ret, U, M, twoWay_out_gga(Terminate, M, Ret1)) -> U17_gga(Terminate, N, Ret, U, isTimes_in_ggg(Ret1, M, U))
   U17_gga(Terminate, N, Ret, U, isTimes_out_ggg(Ret1, M, U)) -> U18_gga(Terminate, N, Ret, =_in_ag(Ret, U))
   U18_gga(Terminate, N, Ret, =_out_ag(Ret, U)) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(succ(zero), X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x3, x4)

zero  =  zero

U4_gga(x1, x2, x3)  =  U4_gga(x3)

isLess_in_gg(x1, x2)  =  isLess_in_gg(x1, x2)

pred(x1)  =  pred(x1)

isLess_out_gg(x1, x2)  =  isLess_out_gg

succ(x1)  =  succ(x1)

U53_gg(x1, x2, x3)  =  U53_gg(x3)

U54_gg(x1, x2, x3)  =  U54_gg(x3)

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x3)

U5_gga(x1, x2, x3, x4)  =  U5_gga(x1, x2, x4)

U6_gga(x1, x2, x3, x4, x5)  =  U6_gga(x1, x2, x4, x5)

U7_gga(x1, x2, x3, x4, x5, x6)  =  U7_gga(x1, x2, x6)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

U8_gga(x1, x2, x3, x4, x5, x6)  =  U8_gga(x1, x6)

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

U9_gga(x1, x2, x3, x4, x5, x6, x7)  =  U9_gga(x1, x6, x7)

U10_gga(x1, x2, x3, x4, x5, x6)  =  U10_gga(x4, x5, x6)

U11_gga(x1, x2, x3, x4, x5)  =  U11_gga(x4, x5)

isTimes_in_ggg(x1, x2, x3)  =  isTimes_in_ggg(x1, x2, x3)

isTimes_out_ggg(x1, x2, x3)  =  isTimes_out_ggg

U30_ggg(x1, x2, x3, x4)  =  U30_ggg(x1, x3, x4)

isTimes_in_gga(x1, x2, x3)  =  isTimes_in_gga(x1, x2)

isTimes_out_gga(x1, x2, x3)  =  isTimes_out_gga(x3)

U30_gga(x1, x2, x3, x4)  =  U30_gga(x1, x4)

U32_gga(x1, x2, x3, x4)  =  U32_gga(x1, x4)

U34_gga(x1, x2, x3, x4)  =  U34_gga(x1, x4)

U36_gga(x1, x2, x3, x4)  =  U36_gga(x1, x4)

U37_gga(x1, x2, x3, x4)  =  U37_gga(x4)

U35_gga(x1, x2, x3, x4)  =  U35_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

U33_gga(x1, x2, x3, x4)  =  U33_gga(x4)

U31_gga(x1, x2, x3, x4)  =  U31_gga(x4)

U31_ggg(x1, x2, x3, x4)  =  U31_ggg(x4)

isPlus_in_ggg(x1, x2, x3)  =  isPlus_in_ggg(x1, x2, x3)

isPlus_out_ggg(x1, x2, x3)  =  isPlus_out_ggg

U20_ggg(x1, x2, x3, x4)  =  U20_ggg(x4)

U21_ggg(x1, x2, x3, x4)  =  U21_ggg(x4)

U22_ggg(x1, x2, x3, x4)  =  U22_ggg(x4)

U23_ggg(x1, x2, x3, x4)  =  U23_ggg(x4)

U32_ggg(x1, x2, x3, x4)  =  U32_ggg(x1, x3, x4)

U33_ggg(x1, x2, x3, x4)  =  U33_ggg(x4)

isMinus_in_ggg(x1, x2, x3)  =  isMinus_in_ggg(x1, x2, x3)

isMinus_out_ggg(x1, x2, x3)  =  isMinus_out_ggg

U24_ggg(x1, x2, x3)  =  U24_ggg(x3)

U25_ggg(x1, x2, x3)  =  U25_ggg(x3)

U26_ggg(x1, x2, x3, x4)  =  U26_ggg(x4)

U27_ggg(x1, x2, x3, x4)  =  U27_ggg(x4)

U28_ggg(x1, x2, x3, x4)  =  U28_ggg(x4)

U29_ggg(x1, x2, x3, x4)  =  U29_ggg(x4)

U34_ggg(x1, x2, x3, x4)  =  U34_ggg(x1, x3, x4)

U35_ggg(x1, x2, x3, x4)  =  U35_ggg(x4)

U36_ggg(x1, x2, x3, x4)  =  U36_ggg(x1, x3, x4)

U37_ggg(x1, x2, x3, x4)  =  U37_ggg(x4)

U12_gga(x1, x2, x3, x4)  =  U12_gga(x4)

U13_gga(x1, x2, x3, x4, x5, x6)  =  U13_gga(x1, x2, x6)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

b  =  b

failure_out_g(x1)  =  failure_out_g

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

U14_gga(x1, x2, x3, x4, x5, x6)  =  U14_gga(x1, x6)

U15_gga(x1, x2, x3, x4, x5, x6, x7)  =  U15_gga(x1, x6, x7)

U16_gga(x1, x2, x3, x4, x5, x6)  =  U16_gga(x4, x5, x6)

U17_gga(x1, x2, x3, x4, x5)  =  U17_gga(x4, x5)

U18_gga(x1, x2, x3, x4)  =  U18_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga(x2)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x6)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x6, x7)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x6, x7)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(201) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(202)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N, Ret) -> U5_GGA(Terminate, N, Ret, =_in_ag(X, Terminate))
   U5_GGA(Terminate, N, Ret, =_out_ag(X, Terminate)) -> U6_GGA(Terminate, N, Ret, X, =_in_ag(X1, succ(zero)))
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U7_GGA(Terminate, N, Ret, X, X1, =_in_gg(X, X1))
   U7_GGA(Terminate, N, Ret, X, X1, =_out_gg(X, X1)) -> U8_GGA(Terminate, N, Ret, X, X1, isMinus_in_gga(N, succ(zero), U))
   U8_GGA(Terminate, N, Ret, X, X1, isMinus_out_gga(N, succ(zero), U)) -> U9_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U9_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)
   U6_GGA(Terminate, N, Ret, X, =_out_ag(X1, succ(zero))) -> U13_GGA(Terminate, N, Ret, X, X1, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, Ret, X, X1, nounify_out_gg(X, X1)) -> U14_GGA(Terminate, N, Ret, X, X1, isPlus_in_gga(N, succ(zero), U))
   U14_GGA(Terminate, N, Ret, X, X1, isPlus_out_gga(N, succ(zero), U)) -> U15_GGA(Terminate, N, Ret, X, X1, U, =_in_ag(M, U))
   U15_GGA(Terminate, N, Ret, X, X1, U, =_out_ag(M, U)) -> TWOWAY_IN_GGA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   =_in_ag(X, X) -> =_out_ag(X, X)
   =_in_gg(X, X) -> =_out_gg(X, X)
   isMinus_in_gga(zero, succ(Y), pred(Z)) -> U24_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), succ(Y), Z) -> U26_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), succ(Y), pred(pred(Z))) -> U28_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   nounify_in_gg(X, Y) -> U19_gg(X, Y, not_in_gg(X, Y))
   isPlus_in_gga(zero, X, X) -> isPlus_out_gga(zero, X, X)
   isPlus_in_gga(succ(X), succ(Y), succ(succ(Z))) -> U20_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), succ(Y), Z) -> U22_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U24_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, succ(Y), pred(Z))
   U26_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), succ(Y), Z)
   U28_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), succ(Y), pred(pred(Z)))
   U19_gg(X, Y, not_out_gg(X, Y)) -> nounify_out_gg(X, Y)
   U20_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), succ(Y), succ(succ(Z)))
   U22_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), succ(Y), Z)
   isMinus_in_gga(X, zero, X) -> isMinus_out_gga(X, zero, X)
   isMinus_in_gga(zero, pred(Y), succ(Z)) -> U25_gga(Y, Z, isMinus_in_gga(zero, Y, Z))
   isMinus_in_gga(succ(X), pred(Y), succ(succ(Z))) -> U27_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   isMinus_in_gga(pred(X), pred(Y), Z) -> U29_gga(X, Y, Z, isMinus_in_gga(X, Y, Z))
   not_in_gg(X, Y) -> U55_gg(X, Y, call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg(X, Y)
   isPlus_in_gga(succ(X), zero, succ(X)) -> isPlus_out_gga(succ(X), zero, succ(X))
   isPlus_in_gga(succ(X), pred(Y), Z) -> U21_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   isPlus_in_gga(pred(X), zero, pred(X)) -> isPlus_out_gga(pred(X), zero, pred(X))
   isPlus_in_gga(pred(X), pred(Y), pred(pred(Z))) -> U23_gga(X, Y, Z, isPlus_in_gga(X, Y, Z))
   U25_gga(Y, Z, isMinus_out_gga(zero, Y, Z)) -> isMinus_out_gga(zero, pred(Y), succ(Z))
   U27_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(succ(X), pred(Y), succ(succ(Z)))
   U29_gga(X, Y, Z, isMinus_out_gga(X, Y, Z)) -> isMinus_out_gga(pred(X), pred(Y), Z)
   U55_gg(X, Y, call1_out_gg(X, Y)) -> U56_gg(X, Y, fail_in_)
   U21_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(succ(X), pred(Y), Z)
   U23_gga(X, Y, Z, isPlus_out_gga(X, Y, Z)) -> isPlus_out_gga(pred(X), pred(Y), pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(X, Y, =_in_gg(X, Y))
   U56_gg(X, Y, fail_out_) -> not_out_gg(X, Y)
   U57_gg(X, Y, =_out_gg(X, Y)) -> call1_out_gg(X, Y)
   fail_in_ -> U58_(failure_in_g(a))

The argument filtering Pi contains the following mapping:
=_in_ag(x1, x2)  =  =_in_ag(x2)

=_out_ag(x1, x2)  =  =_out_ag(x1)

zero  =  zero

pred(x1)  =  pred(x1)

succ(x1)  =  succ(x1)

=_in_gg(x1, x2)  =  =_in_gg(x1, x2)

=_out_gg(x1, x2)  =  =_out_gg

isMinus_in_gga(x1, x2, x3)  =  isMinus_in_gga(x1, x2)

isMinus_out_gga(x1, x2, x3)  =  isMinus_out_gga(x3)

U24_gga(x1, x2, x3)  =  U24_gga(x3)

U25_gga(x1, x2, x3)  =  U25_gga(x3)

U26_gga(x1, x2, x3, x4)  =  U26_gga(x4)

U27_gga(x1, x2, x3, x4)  =  U27_gga(x4)

U28_gga(x1, x2, x3, x4)  =  U28_gga(x4)

U29_gga(x1, x2, x3, x4)  =  U29_gga(x4)

isPlus_in_gga(x1, x2, x3)  =  isPlus_in_gga(x1, x2)

isPlus_out_gga(x1, x2, x3)  =  isPlus_out_gga(x3)

U20_gga(x1, x2, x3, x4)  =  U20_gga(x4)

U21_gga(x1, x2, x3, x4)  =  U21_gga(x4)

U22_gga(x1, x2, x3, x4)  =  U22_gga(x4)

U23_gga(x1, x2, x3, x4)  =  U23_gga(x4)

nounify_in_gg(x1, x2)  =  nounify_in_gg(x1, x2)

U19_gg(x1, x2, x3)  =  U19_gg(x3)

not_in_gg(x1, x2)  =  not_in_gg(x1, x2)

U55_gg(x1, x2, x3)  =  U55_gg(x3)

call1_in_gg(x1, x2)  =  call1_in_gg(x1, x2)

U57_gg(x1, x2, x3)  =  U57_gg(x3)

call1_out_gg(x1, x2)  =  call1_out_gg

U56_gg(x1, x2, x3)  =  U56_gg(x3)

fail_in_  =  fail_in_

U58_(x1)  =  U58_(x1)

failure_in_g(x1)  =  failure_in_g(x1)

a  =  a

fail_out_  =  fail_out_

not_out_gg(x1, x2)  =  not_out_gg

nounify_out_gg(x1, x2)  =  nounify_out_gg

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U5_GGA(x1, x2, x3, x4)  =  U5_GGA(x1, x2, x4)

U6_GGA(x1, x2, x3, x4, x5)  =  U6_GGA(x1, x2, x4, x5)

U7_GGA(x1, x2, x3, x4, x5, x6)  =  U7_GGA(x1, x2, x6)

U8_GGA(x1, x2, x3, x4, x5, x6)  =  U8_GGA(x1, x6)

U9_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U9_GGA(x1, x6, x7)

U13_GGA(x1, x2, x3, x4, x5, x6)  =  U13_GGA(x1, x2, x6)

U14_GGA(x1, x2, x3, x4, x5, x6)  =  U14_GGA(x1, x6)

U15_GGA(x1, x2, x3, x4, x5, x6, x7)  =  U15_GGA(x1, x6, x7)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(203) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(204)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_in_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero)))
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_in_ag(U))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_in_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X)
   =_in_gg(X, X) -> =_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U19_gg(not_out_gg) -> nounify_out_gg
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U56_gg(fail_out_) -> not_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(205) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_in_ag(Terminate)) at position [2] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate)),TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate)))


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

(206)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero)))
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_in_ag(U))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_in_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X)
   =_in_gg(X, X) -> =_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U19_gg(not_out_gg) -> nounify_out_gg
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U56_gg(fail_out_) -> not_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(207) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_in_ag(succ(zero))) at position [3] we obtained the following new rules [LPAR04]:

   (U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero))),U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero))))


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

(208)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_in_ag(U))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_in_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X)
   =_in_gg(X, X) -> =_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U19_gg(not_out_gg) -> nounify_out_gg
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U56_gg(fail_out_) -> not_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(209) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_in_ag(U)) at position [2] we obtained the following new rules [LPAR04]:

   (U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U)),U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U)))


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

(210)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_in_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X)
   =_in_gg(X, X) -> =_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U19_gg(not_out_gg) -> nounify_out_gg
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U56_gg(fail_out_) -> not_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(211) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_in_ag(U)) at position [2] we obtained the following new rules [LPAR04]:

   (U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U)),U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U)))


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

(212)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))

The TRS R consists of the following rules:

   =_in_ag(X) -> =_out_ag(X)
   =_in_gg(X, X) -> =_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U19_gg(not_out_gg) -> nounify_out_gg
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U56_gg(fail_out_) -> not_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   fail_in_ -> U58_(failure_in_g(a))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(213) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(214)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_ag(x0)
   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(215) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =_in_ag(x0)


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

(216)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1))
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(217) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U7_GGA(Terminate, N, =_in_gg(X, X1)) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg),U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg))


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

(218)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1))
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(219) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(Terminate, N, X, =_out_ag(X1)) -> U13_GGA(Terminate, N, nounify_in_gg(X, X1)) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1))),U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1))))


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

(220)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   nounify_in_gg(X, Y) -> U19_gg(not_in_gg(X, Y))
   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(221) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(222)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   nounify_in_gg(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(223) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   nounify_in_gg(x0, x1)


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

(224)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1)))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(225) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_in_gg(x0, x1))) at position [2,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1)))),U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1)))))
   (U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg)),U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg)))


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

(226)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))

The TRS R consists of the following rules:

   not_in_gg(X, Y) -> U55_gg(call1_in_gg(X, Y))
   not_in_gg(X, Y) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(227) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(228)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))

The TRS R consists of the following rules:

   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   not_in_gg(x0, x1)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(229) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   not_in_gg(x0, x1)


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

(230)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1))))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))

The TRS R consists of the following rules:

   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(231) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_in_gg(x0, x1)))) at position [2,0,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1))))),U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1))))))


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

(232)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   U19_gg(not_out_gg) -> nounify_out_gg
   call1_in_gg(X, Y) -> U57_gg(=_in_gg(X, Y))
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(233) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(234)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   call1_in_gg(x0, x1)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(235) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   call1_in_gg(x0, x1)


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

(236)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1)))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(237) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(not_out_gg)) at position [2] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg),U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg))


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

(238)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1)))))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(239) TransformationProof (SOUND)
By narrowing [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_in_gg(x0, x1))))) at position [2,0,0,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg)))),U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg)))))


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

(240)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg))))

The TRS R consists of the following rules:

   =_in_gg(X, X) -> =_out_gg
   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(241) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(242)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg))))

The TRS R consists of the following rules:

   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   =_in_gg(x0, x1)
   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(243) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =_in_gg(x0, x1)


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

(244)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg))))

The TRS R consists of the following rules:

   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(245) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(U57_gg(=_out_gg)))) at position [2,0,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg))),U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg))))


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

(246)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg)))

The TRS R consists of the following rules:

   U57_gg(=_out_gg) -> call1_out_gg
   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(247) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(248)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg)))

The TRS R consists of the following rules:

   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   U57_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(249) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   U57_gg(x0)


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

(250)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg)))

The TRS R consists of the following rules:

   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(251) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U55_gg(call1_out_gg))) at position [2,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_))),U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_))))


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

(252)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_)))

The TRS R consists of the following rules:

   U55_gg(call1_out_gg) -> U56_gg(fail_in_)
   U19_gg(not_out_gg) -> nounify_out_gg
   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(253) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(254)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_)))

The TRS R consists of the following rules:

   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U55_gg(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(255) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   U55_gg(x0)


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

(256)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_)))

The TRS R consists of the following rules:

   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(257) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(fail_in_))) at position [2,0,0] we obtained the following new rules [LPAR04]:

   (U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(U58_(failure_in_g(a))))),U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(U58_(failure_in_g(a))))))


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

(258)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U13_GGA(y0, y1, U19_gg(U56_gg(U58_(failure_in_g(a)))))

The TRS R consists of the following rules:

   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(259) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(260)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)

The TRS R consists of the following rules:

   fail_in_ -> U58_(failure_in_g(a))
   U56_gg(fail_out_) -> not_out_gg
   U19_gg(not_out_gg) -> nounify_out_gg
   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(261) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(262)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U8_GGA(Terminate, isMinus_out_gga(U)) -> U9_GGA(Terminate, U, =_out_ag(U))
   U9_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)
   TWOWAY_IN_GGA(Terminate, N) -> U5_GGA(Terminate, N, =_out_ag(Terminate))
   U5_GGA(Terminate, N, =_out_ag(X)) -> U6_GGA(Terminate, N, X, =_out_ag(succ(zero)))
   U6_GGA(y0, y1, x0, =_out_ag(x0)) -> U7_GGA(y0, y1, =_out_gg)
   U7_GGA(Terminate, N, =_out_gg) -> U8_GGA(Terminate, isMinus_in_gga(N, succ(zero)))
   U6_GGA(y0, y1, x0, =_out_ag(x1)) -> U13_GGA(y0, y1, nounify_out_gg)
   U13_GGA(Terminate, N, nounify_out_gg) -> U14_GGA(Terminate, isPlus_in_gga(N, succ(zero)))
   U14_GGA(Terminate, isPlus_out_gga(U)) -> U15_GGA(Terminate, U, =_out_ag(U))
   U15_GGA(Terminate, U, =_out_ag(M)) -> TWOWAY_IN_GGA(Terminate, M)

The TRS R consists of the following rules:

   isPlus_in_gga(zero, X) -> isPlus_out_gga(X)
   isPlus_in_gga(succ(X), succ(Y)) -> U20_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), succ(Y)) -> U22_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(succ(X), zero) -> isPlus_out_gga(succ(X))
   isPlus_in_gga(succ(X), pred(Y)) -> U21_gga(isPlus_in_gga(X, Y))
   isPlus_in_gga(pred(X), zero) -> isPlus_out_gga(pred(X))
   isPlus_in_gga(pred(X), pred(Y)) -> U23_gga(isPlus_in_gga(X, Y))
   U22_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U23_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(pred(pred(Z)))
   U21_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(Z)
   U20_gga(isPlus_out_gga(Z)) -> isPlus_out_gga(succ(succ(Z)))
   isMinus_in_gga(zero, succ(Y)) -> U24_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), succ(Y)) -> U26_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), succ(Y)) -> U28_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(X, zero) -> isMinus_out_gga(X)
   isMinus_in_gga(zero, pred(Y)) -> U25_gga(isMinus_in_gga(zero, Y))
   isMinus_in_gga(succ(X), pred(Y)) -> U27_gga(isMinus_in_gga(X, Y))
   isMinus_in_gga(pred(X), pred(Y)) -> U29_gga(isMinus_in_gga(X, Y))
   U28_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(pred(Z)))
   U29_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U27_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(succ(Z)))
   U25_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(succ(Z))
   U26_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(Z)
   U24_gga(isMinus_out_gga(Z)) -> isMinus_out_gga(pred(Z))

The set Q consists of the following terms:

   isMinus_in_gga(x0, x1)
   isPlus_in_gga(x0, x1)
   U24_gga(x0)
   U26_gga(x0)
   U28_gga(x0)
   U19_gg(x0)
   U20_gga(x0)
   U22_gga(x0)
   U25_gga(x0)
   U27_gga(x0)
   U29_gga(x0)
   U21_gga(x0)
   U23_gga(x0)
   U56_gg(x0)
   fail_in_

We have to consider all (P,Q,R)-chains.
----------------------------------------

(263) CutEliminatorProof (SOUND)
Eliminated all cuts by simply ignoring them[PROLOG].
----------------------------------------

(264)
Obligation:
Clauses:

main(X, Ret) :- twoWay(1, X, Ret).
twoWay(Terminate, N, 1) :- <(N, 0).
twoWay(Terminate, N, Ret) :- ','(=:=(Terminate, 1), ','(is(M, -(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M))))).
twoWay(Terminate, N, Ret) :- ','(=\=(Terminate, 1), ','(is(M, +(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M))))).


Query: main(g,a)
----------------------------------------

(265) UndefinedPredicateHandlerProof (SOUND)
Added facts for all undefined predicates [PROLOG].
----------------------------------------

(266)
Obligation:
Clauses:

main(X, Ret) :- twoWay(1, X, Ret).
twoWay(Terminate, N, 1) :- <(N, 0).
twoWay(Terminate, N, Ret) :- ','(=:=(Terminate, 1), ','(is(M, -(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M))))).
twoWay(Terminate, N, Ret) :- ','(=\=(Terminate, 1), ','(is(M, +(N, 1)), ','(twoWay(Terminate, M, Ret1), is(Ret, *(Ret1, M))))).
<(X0, X1).
=:=(X0, X1).
is(X0, X1).
=\=(X0, X1).


Query: main(g,a)
----------------------------------------

(267) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

main_in_2: (b,f)

twoWay_in_3: (b,b,f) (b,f,f)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



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

(268)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga



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

(269) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(1, X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(1, X, Ret)
   TWOWAY_IN_GGA(Terminate, N, 1) -> U2_GGA(Terminate, N, <_in_gg(N, 0))
   TWOWAY_IN_GGA(Terminate, N, 1) -> <_IN_GG(N, 0)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U3_GGA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GGA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, 1) -> U2_GAA(Terminate, N, <_in_ag(N, 0))
   TWOWAY_IN_GAA(Terminate, N, 1) -> <_IN_AG(N, 0)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U7_GGA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GGA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x3)

<_IN_GG(x1, x2)  =  <_IN_GG(x1, x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x4)

=:=_IN_GG(x1, x2)  =  =:=_IN_GG(x1, x2)

U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x1, x4)

IS_IN_AG(x1, x2)  =  IS_IN_AG(x2)

U5_GGA(x1, x2, x3, x4, x5)  =  U5_GGA(x5)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U2_GAA(x1, x2, x3)  =  U2_GAA(x3)

<_IN_AG(x1, x2)  =  <_IN_AG(x2)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U5_GAA(x1, x2, x3, x4, x5)  =  U5_GAA(x5)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

=\=_IN_GG(x1, x2)  =  =\=_IN_GG(x1, x2)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)

U9_GAA(x1, x2, x3, x4, x5)  =  U9_GAA(x5)

U10_GAA(x1, x2, x3, x4)  =  U10_GAA(x4)

U6_GAA(x1, x2, x3, x4)  =  U6_GAA(x4)

U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x4)

U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x1, x4)

U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x1, x4)

U9_GGA(x1, x2, x3, x4, x5)  =  U9_GGA(x5)

U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(270)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(1, X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(1, X, Ret)
   TWOWAY_IN_GGA(Terminate, N, 1) -> U2_GGA(Terminate, N, <_in_gg(N, 0))
   TWOWAY_IN_GGA(Terminate, N, 1) -> <_IN_GG(N, 0)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U3_GGA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GGA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, 1) -> U2_GAA(Terminate, N, <_in_ag(N, 0))
   TWOWAY_IN_GAA(Terminate, N, 1) -> <_IN_AG(N, 0)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U7_GGA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GGA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x3)

<_IN_GG(x1, x2)  =  <_IN_GG(x1, x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x4)

=:=_IN_GG(x1, x2)  =  =:=_IN_GG(x1, x2)

U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x1, x4)

IS_IN_AG(x1, x2)  =  IS_IN_AG(x2)

U5_GGA(x1, x2, x3, x4, x5)  =  U5_GGA(x5)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U2_GAA(x1, x2, x3)  =  U2_GAA(x3)

<_IN_AG(x1, x2)  =  <_IN_AG(x2)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U5_GAA(x1, x2, x3, x4, x5)  =  U5_GAA(x5)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

=\=_IN_GG(x1, x2)  =  =\=_IN_GG(x1, x2)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)

U9_GAA(x1, x2, x3, x4, x5)  =  U9_GAA(x5)

U10_GAA(x1, x2, x3, x4)  =  U10_GAA(x4)

U6_GAA(x1, x2, x3, x4)  =  U6_GAA(x4)

U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x4)

U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x1, x4)

U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x1, x4)

U9_GGA(x1, x2, x3, x4, x5)  =  U9_GGA(x5)

U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(271) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 1 SCC with 32 less nodes.
----------------------------------------

(272)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x4)

main_out_ga(x1, x2)  =  main_out_ga

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(273) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(274)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The argument filtering Pi contains the following mapping:
=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg

1  =  1

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag

-(x1, x2)  =  -(x2)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg

+(x1, x2)  =  +(x2)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(275) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(276)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg
   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(277) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_in_gg(Terminate, 1)) at position [1] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg),TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg))


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

(278)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg
   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(279) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(280)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(281) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =:=_in_gg(x0, x1)


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

(282)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(283) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_in_ag(-(1))) at position [1] we obtained the following new rules [LPAR04]:

   (U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag),U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag))


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

(284)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(285) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1)) at position [1] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg),TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg))


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

(286)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag
   =\=_in_gg(X0, X1) -> =\=_out_gg

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(287) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(288)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(289) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =\=_in_gg(x0, x1)


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

(290)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag

The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(291) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_in_ag(+(1))) at position [1] we obtained the following new rules [LPAR04]:

   (U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_out_ag),U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_out_ag))


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

(292)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_out_ag)

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag

The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(293) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(294)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_out_ag)

R is empty.
The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(295) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   is_in_ag(x0)


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

(296)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
   U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg)
   U7_GAA(Terminate, =\=_out_gg) -> U8_GAA(Terminate, is_out_ag)

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(297) NonTerminationLoopProof (COMPLETE)
We used the non-termination processor [FROCOS05] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

s = TWOWAY_IN_GAA(Terminate) evaluates to  t =TWOWAY_IN_GAA(Terminate)

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:
* Matcher: [ ]
* Semiunifier: [ ]

--------------------------------------------------------------------------------
Rewriting sequence

TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg)
with rule TWOWAY_IN_GAA(Terminate') -> U3_GAA(Terminate', =:=_out_gg) at position [] and matcher [Terminate' / Terminate]

U3_GAA(Terminate, =:=_out_gg) -> U4_GAA(Terminate, is_out_ag)
with rule U3_GAA(Terminate', =:=_out_gg) -> U4_GAA(Terminate', is_out_ag) at position [] and matcher [Terminate' / Terminate]

U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)
with rule U4_GAA(Terminate, is_out_ag) -> TWOWAY_IN_GAA(Terminate)

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.




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

(298)
NO

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

(299) PrologToPiTRSProof (SOUND)
We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes:

main_in_2: (b,f)

twoWay_in_3: (b,b,f) (b,f,f)

Transforming Prolog into the following Term Rewriting System:

Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg(x1, x2)

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x2, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x1, x2, x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x1, x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag(x2)

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa(x1)

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x1, x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x1, x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x1, x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x1, x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x1, x2, x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x2, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x1, x2, x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1)





Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



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

(300)
Obligation:
Pi-finite rewrite system:
The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg(x1, x2)

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x2, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x1, x2, x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x1, x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag(x2)

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa(x1)

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x1, x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x1, x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x1, x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x1, x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x1, x2, x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x2, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x1, x2, x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1)



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

(301) DependencyPairsProof (EQUIVALENT)
Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(1, X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(1, X, Ret)
   TWOWAY_IN_GGA(Terminate, N, 1) -> U2_GGA(Terminate, N, <_in_gg(N, 0))
   TWOWAY_IN_GGA(Terminate, N, 1) -> <_IN_GG(N, 0)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U3_GGA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GGA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, 1) -> U2_GAA(Terminate, N, <_in_ag(N, 0))
   TWOWAY_IN_GAA(Terminate, N, 1) -> <_IN_AG(N, 0)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U7_GGA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GGA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg(x1, x2)

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x2, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x1, x2, x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x1, x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag(x2)

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa(x1)

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x1, x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x1, x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x1, x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x1, x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x1, x2, x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x2, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x1, x2, x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x1, x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x1, x2, x3)

<_IN_GG(x1, x2)  =  <_IN_GG(x1, x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x2, x4)

=:=_IN_GG(x1, x2)  =  =:=_IN_GG(x1, x2)

U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x1, x2, x4)

IS_IN_AG(x1, x2)  =  IS_IN_AG(x2)

U5_GGA(x1, x2, x3, x4, x5)  =  U5_GGA(x1, x2, x5)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U2_GAA(x1, x2, x3)  =  U2_GAA(x1, x3)

<_IN_AG(x1, x2)  =  <_IN_AG(x2)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U5_GAA(x1, x2, x3, x4, x5)  =  U5_GAA(x1, x5)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

=\=_IN_GG(x1, x2)  =  =\=_IN_GG(x1, x2)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)

U9_GAA(x1, x2, x3, x4, x5)  =  U9_GAA(x1, x5)

U10_GAA(x1, x2, x3, x4)  =  U10_GAA(x1, x4)

U6_GAA(x1, x2, x3, x4)  =  U6_GAA(x1, x4)

U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x1, x2, x4)

U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x1, x2, x4)

U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x1, x2, x4)

U9_GGA(x1, x2, x3, x4, x5)  =  U9_GGA(x1, x2, x5)

U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x1, x2, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(302)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   MAIN_IN_GA(X, Ret) -> U1_GA(X, Ret, twoWay_in_gga(1, X, Ret))
   MAIN_IN_GA(X, Ret) -> TWOWAY_IN_GGA(1, X, Ret)
   TWOWAY_IN_GGA(Terminate, N, 1) -> U2_GGA(Terminate, N, <_in_gg(N, 0))
   TWOWAY_IN_GGA(Terminate, N, 1) -> <_IN_GG(N, 0)
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U3_GGA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GGA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GGA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GGA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, 1) -> U2_GAA(Terminate, N, <_in_ag(N, 0))
   TWOWAY_IN_GAA(Terminate, N, 1) -> <_IN_AG(N, 0)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =:=_IN_GG(Terminate, 1)
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> IS_IN_AG(M, -(N, 1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GAA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GAA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GAA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GAA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U5_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> U7_GGA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   TWOWAY_IN_GGA(Terminate, N, Ret) -> =\=_IN_GG(Terminate, 1)
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GGA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U7_GGA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> IS_IN_AG(M, +(N, 1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_GGA(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U8_GGA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_GGA(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U9_GGA(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> IS_IN_AG(Ret, *(Ret1, M))

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg(x1, x2)

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x2, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x1, x2, x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x1, x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag(x2)

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa(x1)

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x1, x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x1, x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x1, x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x1, x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x1, x2, x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x2, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x1, x2, x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1)

MAIN_IN_GA(x1, x2)  =  MAIN_IN_GA(x1)

U1_GA(x1, x2, x3)  =  U1_GA(x1, x3)

TWOWAY_IN_GGA(x1, x2, x3)  =  TWOWAY_IN_GGA(x1, x2)

U2_GGA(x1, x2, x3)  =  U2_GGA(x1, x2, x3)

<_IN_GG(x1, x2)  =  <_IN_GG(x1, x2)

U3_GGA(x1, x2, x3, x4)  =  U3_GGA(x1, x2, x4)

=:=_IN_GG(x1, x2)  =  =:=_IN_GG(x1, x2)

U4_GGA(x1, x2, x3, x4)  =  U4_GGA(x1, x2, x4)

IS_IN_AG(x1, x2)  =  IS_IN_AG(x2)

U5_GGA(x1, x2, x3, x4, x5)  =  U5_GGA(x1, x2, x5)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U2_GAA(x1, x2, x3)  =  U2_GAA(x1, x3)

<_IN_AG(x1, x2)  =  <_IN_AG(x2)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U5_GAA(x1, x2, x3, x4, x5)  =  U5_GAA(x1, x5)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

=\=_IN_GG(x1, x2)  =  =\=_IN_GG(x1, x2)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)

U9_GAA(x1, x2, x3, x4, x5)  =  U9_GAA(x1, x5)

U10_GAA(x1, x2, x3, x4)  =  U10_GAA(x1, x4)

U6_GAA(x1, x2, x3, x4)  =  U6_GAA(x1, x4)

U6_GGA(x1, x2, x3, x4)  =  U6_GGA(x1, x2, x4)

U7_GGA(x1, x2, x3, x4)  =  U7_GGA(x1, x2, x4)

U8_GGA(x1, x2, x3, x4)  =  U8_GGA(x1, x2, x4)

U9_GGA(x1, x2, x3, x4, x5)  =  U9_GGA(x1, x2, x5)

U10_GGA(x1, x2, x3, x4)  =  U10_GGA(x1, x2, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(303) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LOPSTR] contains 1 SCC with 32 less nodes.
----------------------------------------

(304)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   main_in_ga(X, Ret) -> U1_ga(X, Ret, twoWay_in_gga(1, X, Ret))
   twoWay_in_gga(Terminate, N, 1) -> U2_gga(Terminate, N, <_in_gg(N, 0))
   <_in_gg(X0, X1) -> <_out_gg(X0, X1)
   U2_gga(Terminate, N, <_out_gg(N, 0)) -> twoWay_out_gga(Terminate, N, 1)
   twoWay_in_gga(Terminate, N, Ret) -> U3_gga(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   U3_gga(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gga(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   U4_gga(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, 1) -> U2_gaa(Terminate, N, <_in_ag(N, 0))
   <_in_ag(X0, X1) -> <_out_ag(X0, X1)
   U2_gaa(Terminate, N, <_out_ag(N, 0)) -> twoWay_out_gaa(Terminate, N, 1)
   twoWay_in_gaa(Terminate, N, Ret) -> U3_gaa(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_gaa(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_gaa(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_gaa(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> U5_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   twoWay_in_gaa(Terminate, N, Ret) -> U7_gaa(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)
   U7_gaa(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gaa(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gaa(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gaa(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gaa(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gaa(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gaa(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gaa(Terminate, N, Ret)
   U5_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U6_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U6_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   twoWay_in_gga(Terminate, N, Ret) -> U7_gga(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_gga(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_gga(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_gga(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> U9_gga(Terminate, N, Ret, M, twoWay_in_gaa(Terminate, M, Ret1))
   U9_gga(Terminate, N, Ret, M, twoWay_out_gaa(Terminate, M, Ret1)) -> U10_gga(Terminate, N, Ret, is_in_ag(Ret, *(Ret1, M)))
   U10_gga(Terminate, N, Ret, is_out_ag(Ret, *(Ret1, M))) -> twoWay_out_gga(Terminate, N, Ret)
   U1_ga(X, Ret, twoWay_out_gga(1, X, Ret)) -> main_out_ga(X, Ret)

The argument filtering Pi contains the following mapping:
main_in_ga(x1, x2)  =  main_in_ga(x1)

U1_ga(x1, x2, x3)  =  U1_ga(x1, x3)

twoWay_in_gga(x1, x2, x3)  =  twoWay_in_gga(x1, x2)

U2_gga(x1, x2, x3)  =  U2_gga(x1, x2, x3)

<_in_gg(x1, x2)  =  <_in_gg(x1, x2)

<_out_gg(x1, x2)  =  <_out_gg(x1, x2)

0  =  0

twoWay_out_gga(x1, x2, x3)  =  twoWay_out_gga(x1, x2)

U3_gga(x1, x2, x3, x4)  =  U3_gga(x1, x2, x4)

=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

U4_gga(x1, x2, x3, x4)  =  U4_gga(x1, x2, x4)

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

U5_gga(x1, x2, x3, x4, x5)  =  U5_gga(x1, x2, x5)

twoWay_in_gaa(x1, x2, x3)  =  twoWay_in_gaa(x1)

U2_gaa(x1, x2, x3)  =  U2_gaa(x1, x3)

<_in_ag(x1, x2)  =  <_in_ag(x2)

<_out_ag(x1, x2)  =  <_out_ag(x2)

twoWay_out_gaa(x1, x2, x3)  =  twoWay_out_gaa(x1)

U3_gaa(x1, x2, x3, x4)  =  U3_gaa(x1, x4)

U4_gaa(x1, x2, x3, x4)  =  U4_gaa(x1, x4)

U5_gaa(x1, x2, x3, x4, x5)  =  U5_gaa(x1, x5)

U7_gaa(x1, x2, x3, x4)  =  U7_gaa(x1, x4)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

U8_gaa(x1, x2, x3, x4)  =  U8_gaa(x1, x4)

+(x1, x2)  =  +(x2)

U9_gaa(x1, x2, x3, x4, x5)  =  U9_gaa(x1, x5)

U10_gaa(x1, x2, x3, x4)  =  U10_gaa(x1, x4)

*(x1, x2)  =  *

U6_gaa(x1, x2, x3, x4)  =  U6_gaa(x1, x4)

U6_gga(x1, x2, x3, x4)  =  U6_gga(x1, x2, x4)

U7_gga(x1, x2, x3, x4)  =  U7_gga(x1, x2, x4)

U8_gga(x1, x2, x3, x4)  =  U8_gga(x1, x2, x4)

U9_gga(x1, x2, x3, x4, x5)  =  U9_gga(x1, x2, x5)

U10_gga(x1, x2, x3, x4)  =  U10_gga(x1, x2, x4)

main_out_ga(x1, x2)  =  main_out_ga(x1)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(305) UsableRulesProof (EQUIVALENT)
For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R.
----------------------------------------

(306)
Obligation:
Pi DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate, N, Ret) -> U3_GAA(Terminate, N, Ret, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, N, Ret, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, N, Ret, is_in_ag(M, -(N, 1)))
   U4_GAA(Terminate, N, Ret, is_out_ag(M, -(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)
   TWOWAY_IN_GAA(Terminate, N, Ret) -> U7_GAA(Terminate, N, Ret, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, N, Ret, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, N, Ret, is_in_ag(M, +(N, 1)))
   U8_GAA(Terminate, N, Ret, is_out_ag(M, +(N, 1))) -> TWOWAY_IN_GAA(Terminate, M, Ret1)

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   is_in_ag(X0, X1) -> is_out_ag(X0, X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The argument filtering Pi contains the following mapping:
=:=_in_gg(x1, x2)  =  =:=_in_gg(x1, x2)

=:=_out_gg(x1, x2)  =  =:=_out_gg(x1, x2)

1  =  1

is_in_ag(x1, x2)  =  is_in_ag(x2)

is_out_ag(x1, x2)  =  is_out_ag(x2)

-(x1, x2)  =  -(x2)

=\=_in_gg(x1, x2)  =  =\=_in_gg(x1, x2)

=\=_out_gg(x1, x2)  =  =\=_out_gg(x1, x2)

+(x1, x2)  =  +(x2)

TWOWAY_IN_GAA(x1, x2, x3)  =  TWOWAY_IN_GAA(x1)

U3_GAA(x1, x2, x3, x4)  =  U3_GAA(x1, x4)

U4_GAA(x1, x2, x3, x4)  =  U4_GAA(x1, x4)

U7_GAA(x1, x2, x3, x4)  =  U7_GAA(x1, x4)

U8_GAA(x1, x2, x3, x4)  =  U8_GAA(x1, x4)


We have to consider all (P,R,Pi)-chains
----------------------------------------

(307) PiDPToQDPProof (SOUND)
Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi.
----------------------------------------

(308)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_in_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(309) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_in_gg(Terminate, 1)) at position [1] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1)),TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1)))


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

(310)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   =:=_in_gg(X0, X1) -> =:=_out_gg(X0, X1)
   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(311) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(312)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   =:=_in_gg(x0, x1)
   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(313) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =:=_in_gg(x0, x1)


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

(314)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_in_ag(-(1)))
   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(315) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_in_ag(-(1))) at position [1] we obtained the following new rules [LPAR04]:

   (U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1))),U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1))))


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

(316)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(317) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_in_gg(Terminate, 1)) at position [1] we obtained the following new rules [LPAR04]:

   (TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1)),TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1)))


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

(318)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)
   =\=_in_gg(X0, X1) -> =\=_out_gg(X0, X1)

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(319) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(320)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)

The set Q consists of the following terms:

   is_in_ag(x0)
   =\=_in_gg(x0, x1)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(321) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   =\=_in_gg(x0, x1)


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

(322)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1)))
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)

The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(323) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_in_ag(+(1))) at position [1] we obtained the following new rules [LPAR04]:

   (U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_out_ag(+(1))),U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_out_ag(+(1))))


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

(324)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_out_ag(+(1)))

The TRS R consists of the following rules:

   is_in_ag(X1) -> is_out_ag(X1)

The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(325) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(326)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_out_ag(+(1)))

R is empty.
The set Q consists of the following terms:

   is_in_ag(x0)

We have to consider all (P,Q,R)-chains.
----------------------------------------

(327) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   is_in_ag(x0)


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

(328)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   U4_GAA(Terminate, is_out_ag(-(1))) -> TWOWAY_IN_GAA(Terminate)
   U8_GAA(Terminate, is_out_ag(+(1))) -> TWOWAY_IN_GAA(Terminate)
   TWOWAY_IN_GAA(Terminate) -> U3_GAA(Terminate, =:=_out_gg(Terminate, 1))
   U3_GAA(Terminate, =:=_out_gg(Terminate, 1)) -> U4_GAA(Terminate, is_out_ag(-(1)))
   TWOWAY_IN_GAA(Terminate) -> U7_GAA(Terminate, =\=_out_gg(Terminate, 1))
   U7_GAA(Terminate, =\=_out_gg(Terminate, 1)) -> U8_GAA(Terminate, is_out_ag(+(1)))

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
----------------------------------------

(329) PrologToIRSwTTransformerProof (SOUND)
Transformed Prolog program to IRSwT according to method in Master Thesis of A. Weinert

{
    "root": 1,
    "program": {
        "directives": [],
        "clauses": [
            [
                "(main X Ret)",
                "(twoWay (1) X Ret)"
            ],
            [
                "(twoWay Terminate N (1))",
                "(',' (< N (0)) (!))"
            ],
            [
                "(twoWay Terminate N Ret)",
                "(',' (=:= Terminate (1)) (',' (!) (',' (is M (- N (1))) (',' (twoWay Terminate M Ret1) (is Ret (* Ret1 M))))))"
            ],
            [
                "(twoWay Terminate N Ret)",
                "(',' (=\\= Terminate (1)) (',' (!) (',' (is M (+ N (1))) (',' (twoWay Terminate M Ret1) (is Ret (* Ret1 M))))))"
            ]
        ]
    },
    "graph": {
        "nodes": {
            "22": {
                "goal": [
                    {
                        "clause": -1,
                        "scope": -1,
                        "term": "(!_2)"
                    },
                    {
                        "clause": 2,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    },
                    {
                        "clause": 3,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    }
                ],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": "<"
                        }]
                    },
                    "ground": ["T15"],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "23": {
                "goal": [
                    {
                        "clause": 2,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    },
                    {
                        "clause": 3,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    }
                ],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": ">="
                        }]
                    },
                    "ground": ["T15"],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "24": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(true)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": "<"
                        }]
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "25": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": "<"
                        }]
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "26": {
                "goal": [{
                    "clause": 2,
                    "scope": 2,
                    "term": "(twoWay (1) T15 T11)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": ">="
                        }]
                    },
                    "ground": ["T15"],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "27": {
                "goal": [{
                    "clause": 3,
                    "scope": 2,
                    "term": "(twoWay (1) T15 T11)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T15",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "0"
                            },
                            "operation": ">="
                        }]
                    },
                    "ground": ["T15"],
                    "free": [],
                    "exprvars": ["T15"]
                }
            },
            "type": "Nodes",
            "2921": {
                "goal": [],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T62 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "operation": "="
                        }]
                    },
                    "ground": ["T62"],
                    "free": [
                        "X15",
                        "X16",
                        "X89",
                        "X90"
                    ],
                    "exprvars": []
                }
            },
            "2600": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (=\\= (1) (1)) (',' (!_2) (',' (is X89 (+ T62 (1))) (',' (twoWay (1) X89 X90) (is T64 (* X90 X89))))))"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T62 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T62"],
                    "free": [
                        "X15",
                        "X16",
                        "X89",
                        "X90"
                    ],
                    "exprvars": []
                }
            },
            "653": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T39"],
                    "free": [
                        "X53",
                        "X54"
                    ],
                    "exprvars": [
                        "T39",
                        "T15"
                    ]
                }
            },
            "655": {
                "goal": [{
                    "clause": 2,
                    "scope": 2,
                    "term": "(twoWay (1) T9 T11)"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T9 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T9"],
                    "free": [
                        "X15",
                        "X16"
                    ],
                    "exprvars": []
                }
            },
            "656": {
                "goal": [{
                    "clause": 3,
                    "scope": 2,
                    "term": "(twoWay (1) T9 T11)"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T9 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T9"],
                    "free": [
                        "X15",
                        "X16"
                    ],
                    "exprvars": []
                }
            },
            "832": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (!_2) (',' (is X74 (- T52 (1))) (',' (twoWay (1) X74 X75) (is T54 (* X75 X74)))))"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T52 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "operation": "="
                        }]
                    },
                    "ground": ["T52"],
                    "free": [
                        "X15",
                        "X16",
                        "X74",
                        "X75"
                    ],
                    "exprvars": []
                }
            },
            "657": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (=:= (1) (1)) (',' (!_2) (',' (is X74 (- T52 (1))) (',' (twoWay (1) X74 X75) (is T54 (* X75 X74))))))"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T52 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T52"],
                    "free": [
                        "X15",
                        "X16",
                        "X74",
                        "X75"
                    ],
                    "exprvars": []
                }
            },
            "833": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (is X74 (- T52 (1))) (',' (twoWay (1) X74 X75) (is T54 (* X75 X74))))"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T52 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "type": "PlainIntegerConstant",
                                "value": "1"
                            },
                            "operation": "="
                        }]
                    },
                    "ground": ["T52"],
                    "free": [
                        "X15",
                        "X16",
                        "X74",
                        "X75"
                    ],
                    "exprvars": []
                }
            },
            "71": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T33",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "arguments": [
                                    {
                                        "name": "T31",
                                        "type": "PlainIntegerVariable"
                                    },
                                    {
                                        "name": "T29",
                                        "type": "PlainIntegerVariable"
                                    }
                                ],
                                "type": "PlainIntegerOperation",
                                "operation": "*"
                            },
                            "operation": "="
                        }]
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": [
                        "T31",
                        "T29",
                        "T33"
                    ]
                }
            },
            "835": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "836": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (twoWay (1) T55 X75) (is T54 (* X75 T55)))"
                }],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T52 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T55",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "arguments": [
                                        {
                                            "name": "T52",
                                            "type": "PlainIntegerVariable"
                                        },
                                        {
                                            "type": "PlainIntegerConstant",
                                            "value": "1"
                                        }
                                    ],
                                    "type": "PlainIntegerOperation",
                                    "operation": "-"
                                },
                                "operation": "="
                            }
                        ]
                    },
                    "ground": [
                        "T52",
                        "T55"
                    ],
                    "free": [
                        "X15",
                        "X16",
                        "X74",
                        "X75"
                    ],
                    "exprvars": [
                        "T52",
                        "T55"
                    ]
                }
            },
            "52": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (!_2) (',' (is X36 (- T26 (1))) (',' (twoWay (1) X36 X37) (is T28 (* X37 X36)))))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T26"],
                    "free": [
                        "X36",
                        "X37"
                    ],
                    "exprvars": [
                        "T15",
                        "T26"
                    ]
                }
            },
            "54": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (is X36 (- T26 (1))) (',' (twoWay (1) X36 X37) (is T28 (* X37 X36))))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T26"],
                    "free": [
                        "X36",
                        "X37"
                    ],
                    "exprvars": [
                        "T15",
                        "T26"
                    ]
                }
            },
            "55": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (twoWay (1) T29 X37) (is T28 (* X37 T29)))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T29",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "arguments": [
                                        {
                                            "name": "T26",
                                            "type": "PlainIntegerVariable"
                                        },
                                        {
                                            "type": "PlainIntegerConstant",
                                            "value": "1"
                                        }
                                    ],
                                    "type": "PlainIntegerOperation",
                                    "operation": "-"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": [
                        "T29",
                        "T26"
                    ],
                    "free": [
                        "X36",
                        "X37"
                    ],
                    "exprvars": [
                        "T29",
                        "T15",
                        "T26"
                    ]
                }
            },
            "34": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (=:= (1) (1)) (',' (!_2) (',' (is X36 (- T26 (1))) (',' (twoWay (1) X36 X37) (is T28 (* X37 X36))))))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T26"],
                    "free": [
                        "X36",
                        "X37"
                    ],
                    "exprvars": [
                        "T15",
                        "T26"
                    ]
                }
            },
            "56": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(twoWay (1) T29 X37)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "1"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T29",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "arguments": [
                                        {
                                            "name": "T26",
                                            "type": "PlainIntegerVariable"
                                        },
                                        {
                                            "type": "PlainIntegerConstant",
                                            "value": "1"
                                        }
                                    ],
                                    "type": "PlainIntegerOperation",
                                    "operation": "-"
                                },
                                "operation": "="
                            },
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T29"],
                    "free": ["X37"],
                    "exprvars": [
                        "T29",
                        "T15",
                        "T26"
                    ]
                }
            },
            "57": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(is T28 (* T31 T29))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [
                        "T29",
                        "T31"
                    ],
                    "free": [],
                    "exprvars": []
                }
            },
            "18": {
                "goal": [
                    {
                        "clause": 1,
                        "scope": 2,
                        "term": "(twoWay (1) T9 T11)"
                    },
                    {
                        "clause": 2,
                        "scope": 2,
                        "term": "(twoWay (1) T9 T11)"
                    },
                    {
                        "clause": 3,
                        "scope": 2,
                        "term": "(twoWay (1) T9 T11)"
                    }
                ],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T9"],
                    "free": [],
                    "exprvars": []
                }
            },
            "19": {
                "goal": [
                    {
                        "clause": -1,
                        "scope": -1,
                        "term": "(',' (< T15 (0)) (!_2))"
                    },
                    {
                        "clause": 2,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    },
                    {
                        "clause": 3,
                        "scope": 2,
                        "term": "(twoWay (1) T15 T11)"
                    }
                ],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T15"],
                    "free": [],
                    "exprvars": []
                }
            },
            "1": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(main T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T1"],
                    "free": [],
                    "exprvars": []
                }
            },
            "6": {
                "goal": [{
                    "clause": 0,
                    "scope": 1,
                    "term": "(main T1 T2)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T1"],
                    "free": [],
                    "exprvars": []
                }
            },
            "8": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(twoWay (1) T9 T11)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T9"],
                    "free": [],
                    "exprvars": []
                }
            },
            "81": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(',' (=\\= (1) (1)) (',' (!_2) (',' (is X53 (+ T39 (1))) (',' (twoWay (1) X53 X54) (is T41 (* X54 X53))))))"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [
                            {
                                "lhs": {
                                    "name": "T15",
                                    "type": "PlainIntegerVariable"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            },
                            {
                                "lhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "type": "PlainIntegerRelation",
                                "rhs": {
                                    "type": "PlainIntegerConstant",
                                    "value": "0"
                                },
                                "operation": ">="
                            }
                        ]
                    },
                    "ground": ["T39"],
                    "free": [
                        "X53",
                        "X54"
                    ],
                    "exprvars": [
                        "T39",
                        "T15"
                    ]
                }
            },
            "60": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            },
            "62": {
                "goal": [{
                    "clause": -1,
                    "scope": -1,
                    "term": "(true)"
                }],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": [{
                            "lhs": {
                                "name": "T33",
                                "type": "PlainIntegerVariable"
                            },
                            "type": "PlainIntegerRelation",
                            "rhs": {
                                "arguments": [
                                    {
                                        "name": "T31",
                                        "type": "PlainIntegerVariable"
                                    },
                                    {
                                        "name": "T29",
                                        "type": "PlainIntegerVariable"
                                    }
                                ],
                                "type": "PlainIntegerOperation",
                                "operation": "*"
                            },
                            "operation": "="
                        }]
                    },
                    "ground": [
                        "T31",
                        "T29",
                        "T33"
                    ],
                    "free": [],
                    "exprvars": [
                        "T31",
                        "T29",
                        "T33"
                    ]
                }
            },
            "63": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [
                        "T31",
                        "T29"
                    ],
                    "free": [],
                    "exprvars": [
                        "T31",
                        "T29"
                    ]
                }
            },
            "20": {
                "goal": [
                    {
                        "clause": 2,
                        "scope": 2,
                        "term": "(twoWay (1) T9 T11)"
                    },
                    {
                        "clause": 3,
                        "scope": 2,
                        "term": "(twoWay (1) T9 T11)"
                    }
                ],
                "kb": {
                    "nonunifying": [[
                        "(twoWay (1) T9 T11)",
                        "(twoWay X15 X16 (1))"
                    ]],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": ["T9"],
                    "free": [
                        "X15",
                        "X16"
                    ],
                    "exprvars": []
                }
            },
            "21": {
                "goal": [],
                "kb": {
                    "nonunifying": [],
                    "intvars": {},
                    "arithmetic": {
                        "type": "PlainIntegerRelationState",
                        "relations": []
                    },
                    "ground": [],
                    "free": [],
                    "exprvars": []
                }
            }
        },
        "edges": [
            {
                "from": 1,
                "to": 6,
                "label": "CASE"
            },
            {
                "from": 6,
                "to": 8,
                "label": "ONLY EVAL with clause\nmain(X7, X8) :- twoWay(1, X7, X8).\nand substitutionT1 -> T9,\nX7 -> T9,\nT2 -> T11,\nX8 -> T11,\nT10 -> T11"
            },
            {
                "from": 8,
                "to": 18,
                "label": "CASE"
            },
            {
                "from": 18,
                "to": 19,
                "label": "EVAL with clause\ntwoWay(X15, X16, 1) :- ','(<(X16, 0), !_2).\nand substitutionX15 -> 1,\nT9 -> T15,\nX16 -> T15,\nT11 -> 1"
            },
            {
                "from": 18,
                "to": 20,
                "label": "EVAL-BACKTRACK"
            },
            {
                "from": 19,
                "to": 21,
                "label": "IS ERROR"
            },
            {
                "from": 19,
                "to": 22,
                "label": "ARITHCOMP SUCCESS"
            },
            {
                "from": 19,
                "to": 23,
                "label": "ARITHCOMP FAIL"
            },
            {
                "from": 20,
                "to": 655,
                "label": "PARALLEL"
            },
            {
                "from": 20,
                "to": 656,
                "label": "PARALLEL"
            },
            {
                "from": 22,
                "to": 24,
                "label": "CUT"
            },
            {
                "from": 23,
                "to": 26,
                "label": "PARALLEL"
            },
            {
                "from": 23,
                "to": 27,
                "label": "PARALLEL"
            },
            {
                "from": 24,
                "to": 25,
                "label": "SUCCESS"
            },
            {
                "from": 26,
                "to": 34,
                "label": "ONLY EVAL with clause\ntwoWay(X33, X34, X35) :- ','(=:=(X33, 1), ','(!_2, ','(is(X36, -(X34, 1)), ','(twoWay(X33, X36, X37), is(X35, *(X37, X36)))))).\nand substitutionX33 -> 1,\nT15 -> T26,\nX34 -> T26,\nT11 -> T28,\nX35 -> T28,\nT27 -> T28"
            },
            {
                "from": 27,
                "to": 81,
                "label": "ONLY EVAL with clause\ntwoWay(X50, X51, X52) :- ','(=\\=(X50, 1), ','(!_2, ','(is(X53, +(X51, 1)), ','(twoWay(X50, X53, X54), is(X52, *(X54, X53)))))).\nand substitutionX50 -> 1,\nT15 -> T39,\nX51 -> T39,\nT11 -> T41,\nX52 -> T41,\nT40 -> T41"
            },
            {
                "from": 34,
                "to": 52,
                "label": "ARITHCOMP SUCCESS"
            },
            {
                "from": 52,
                "to": 54,
                "label": "CUT"
            },
            {
                "from": 54,
                "to": 55,
                "label": "\nX36 -> T29"
            },
            {
                "from": 55,
                "to": 56,
                "label": "SPLIT 1"
            },
            {
                "from": 55,
                "to": 57,
                "label": "SPLIT 2\nnew knowledge:\nT29 is ground\nT31 is ground\nreplacements:X37 -> T31"
            },
            {
                "from": 56,
                "to": 8,
                "label": "INSTANCE with matching:\nT9 -> T29\nT11 -> X37"
            },
            {
                "from": 57,
                "to": 60,
                "label": "IS ERROR"
            },
            {
                "from": 57,
                "to": 62,
                "label": "\nT28 -> T33"
            },
            {
                "from": 57,
                "to": 63,
                "label": "IS FAIL"
            },
            {
                "from": 62,
                "to": 71,
                "label": "SUCCESS"
            },
            {
                "from": 81,
                "to": 653,
                "label": "ARITHCOMP FAIL"
            },
            {
                "from": 655,
                "to": 657,
                "label": "ONLY EVAL with clause\ntwoWay(X71, X72, X73) :- ','(=:=(X71, 1), ','(!_2, ','(is(X74, -(X72, 1)), ','(twoWay(X71, X74, X75), is(X73, *(X75, X74)))))).\nand substitutionX71 -> 1,\nT9 -> T52,\nX72 -> T52,\nT11 -> T54,\nX73 -> T54,\nT53 -> T54"
            },
            {
                "from": 656,
                "to": 2600,
                "label": "ONLY EVAL with clause\ntwoWay(X86, X87, X88) :- ','(=\\=(X86, 1), ','(!_2, ','(is(X89, +(X87, 1)), ','(twoWay(X86, X89, X90), is(X88, *(X90, X89)))))).\nand substitutionX86 -> 1,\nT9 -> T62,\nX87 -> T62,\nT11 -> T64,\nX88 -> T64,\nT63 -> T64"
            },
            {
                "from": 657,
                "to": 832,
                "label": "ARITHCOMP SUCCESS"
            },
            {
                "from": 832,
                "to": 833,
                "label": "CUT"
            },
            {
                "from": 833,
                "to": 835,
                "label": "IS ERROR"
            },
            {
                "from": 833,
                "to": 836,
                "label": "\nX74 -> T55"
            },
            {
                "from": 836,
                "to": 55,
                "label": "INSTANCE with matching:\nT29 -> T55\nX37 -> X75\nT28 -> T54\nX36 -> X15"
            },
            {
                "from": 2600,
                "to": 2921,
                "label": "ARITHCOMP FAIL"
            }
        ],
        "type": "Graph"
    }
}

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

(330)
Obligation:
Rules:
f832_in(T52) -> f833_in(T52) :|: TRUE
f833_out(x) -> f832_out(x) :|: TRUE
f20_out(T9) -> f18_out(T9) :|: TRUE
f18_in(T15) -> f19_in(T15) :|: TRUE
f19_out(x1) -> f18_out(x1) :|: TRUE
f18_in(x2) -> f20_in(x2) :|: TRUE
f657_in(x3) -> f832_in(x3) :|: 1 = 1
f832_out(x4) -> f657_out(x4) :|: 1 = 1
f23_in(x5) -> f27_in(x5) :|: TRUE
f23_in(x6) -> f26_in(x6) :|: TRUE
f26_out(x7) -> f23_out(x7) :|: TRUE
f27_out(x8) -> f23_out(x8) :|: TRUE
f8_out(T29) -> f56_out(T29) :|: TRUE
f56_in(x9) -> f8_in(x9) :|: TRUE
f62_in(x10, x11, x12) -> f62_out(x10, x11, x12) :|: TRUE
f52_in(T26) -> f54_in(T26) :|: TRUE
f54_out(x13) -> f52_out(x13) :|: TRUE
f8_in(x14) -> f18_in(x14) :|: TRUE
f18_out(x15) -> f8_out(x15) :|: TRUE
f836_in(x16, x17) -> f55_in(x16, x18) :|: TRUE
f55_out(x19, x20) -> f836_out(x19, x21) :|: TRUE
f52_out(x22) -> f34_out(x22) :|: 1 = 1
f34_in(x23) -> f52_in(x23) :|: 1 = 1
f22_out(x24) -> f19_out(x24) :|: x24 < 0
f21_out -> f19_out(x25) :|: TRUE
f19_in(x26) -> f23_in(x26) :|: x26 >= 0
f19_in(x27) -> f22_in(x27) :|: x27 < 0
f19_in(x28) -> f21_in :|: TRUE
f23_out(x29) -> f19_out(x29) :|: x29 >= 0
f55_out(x30, x31) -> f54_out(x31) :|: TRUE
f54_in(x32) -> f55_in(x33, x32) :|: x33 = x32 - 1
f655_in(x34) -> f657_in(x34) :|: TRUE
f657_out(x35) -> f655_out(x35) :|: TRUE
f655_out(x36) -> f20_out(x36) :|: TRUE
f20_in(x37) -> f655_in(x37) :|: TRUE
f20_in(x38) -> f656_in(x38) :|: TRUE
f656_out(x39) -> f20_out(x39) :|: TRUE
f34_out(x40) -> f26_out(x40) :|: TRUE
f26_in(x41) -> f34_in(x41) :|: TRUE
f57_in(x42, x43) -> f60_in :|: TRUE
f62_out(x44, x45, x46) -> f57_out(x44, x45) :|: TRUE
f57_in(x47, x48) -> f62_in(x47, x48, x49) :|: x49 = x47 * x48
f63_out(x50, x51) -> f57_out(x50, x51) :|: TRUE
f60_out -> f57_out(x52, x53) :|: TRUE
f57_in(x54, x55) -> f63_in(x54, x55) :|: !(x56 = x54 * x55)
f836_out(x57, x58) -> f833_out(x58) :|: TRUE
f833_in(x59) -> f835_in :|: TRUE
f833_in(x60) -> f836_in(x61, x60) :|: x61 = x60 - 1
f835_out -> f833_out(x62) :|: TRUE
f57_out(x63, x64) -> f55_out(x64, x65) :|: TRUE
f55_in(x66, x67) -> f56_in(x66) :|: TRUE
f56_out(x68) -> f57_in(x69, x68) :|: TRUE
f1_in(T1) -> f6_in(T1) :|: TRUE
f6_out(x70) -> f1_out(x70) :|: TRUE
f6_in(x71) -> f8_in(x71) :|: TRUE
f8_out(x72) -> f6_out(x72) :|: TRUE
Start term: f1_in(T1)

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

(331) IRSwTSimpleDependencyGraphProof (EQUIVALENT)
Constructed simple dependency graph.

Simplified to the following IRSwTs:

intTRSProblem:
f832_in(T52) -> f833_in(T52) :|: TRUE
f18_in(T15) -> f19_in(T15) :|: TRUE
f18_in(x2) -> f20_in(x2) :|: TRUE
f657_in(x3) -> f832_in(x3) :|: 1 = 1
f23_in(x6) -> f26_in(x6) :|: TRUE
f56_in(x9) -> f8_in(x9) :|: TRUE
f52_in(T26) -> f54_in(T26) :|: TRUE
f8_in(x14) -> f18_in(x14) :|: TRUE
f836_in(x16, x17) -> f55_in(x16, x18) :|: TRUE
f34_in(x23) -> f52_in(x23) :|: 1 = 1
f19_in(x26) -> f23_in(x26) :|: x26 >= 0
f54_in(x32) -> f55_in(x33, x32) :|: x33 = x32 - 1
f655_in(x34) -> f657_in(x34) :|: TRUE
f20_in(x37) -> f655_in(x37) :|: TRUE
f26_in(x41) -> f34_in(x41) :|: TRUE
f833_in(x60) -> f836_in(x61, x60) :|: x61 = x60 - 1
f55_in(x66, x67) -> f56_in(x66) :|: TRUE


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

(332)
Obligation:
Rules:
f832_in(T52) -> f833_in(T52) :|: TRUE
f18_in(T15) -> f19_in(T15) :|: TRUE
f18_in(x2) -> f20_in(x2) :|: TRUE
f657_in(x3) -> f832_in(x3) :|: 1 = 1
f23_in(x6) -> f26_in(x6) :|: TRUE
f56_in(x9) -> f8_in(x9) :|: TRUE
f52_in(T26) -> f54_in(T26) :|: TRUE
f8_in(x14) -> f18_in(x14) :|: TRUE
f836_in(x16, x17) -> f55_in(x16, x18) :|: TRUE
f34_in(x23) -> f52_in(x23) :|: 1 = 1
f19_in(x26) -> f23_in(x26) :|: x26 >= 0
f54_in(x32) -> f55_in(x33, x32) :|: x33 = x32 - 1
f655_in(x34) -> f657_in(x34) :|: TRUE
f20_in(x37) -> f655_in(x37) :|: TRUE
f26_in(x41) -> f34_in(x41) :|: TRUE
f833_in(x60) -> f836_in(x61, x60) :|: x61 = x60 - 1
f55_in(x66, x67) -> f56_in(x66) :|: TRUE

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

(333) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(334)
Obligation:
Rules:
f56_in(x9:0) -> f56_in(x9:0 - 1) :|: TRUE
f56_in(x) -> f56_in(x - 1) :|: x > -1

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

(335) IRSFormatTransformerProof (EQUIVALENT)
Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %).
----------------------------------------

(336)
Obligation:
Rules:
f56_in(x9:0) -> f56_in(arith) :|: TRUE && arith = x9:0 - 1
f56_in(x1) -> f56_in(x2) :|: x1 > -1 && x2 = x1 - 1

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

(337) IRSwTTerminationDigraphProof (EQUIVALENT)
Constructed termination digraph!
Nodes:
(1) f56_in(x9:0) -> f56_in(arith) :|: TRUE && arith = x9:0 - 1
(2) f56_in(x1) -> f56_in(x2) :|: x1 > -1 && x2 = x1 - 1

Arcs:
(1) -> (1), (2)
(2) -> (1), (2)

This digraph is fully evaluated!
----------------------------------------

(338)
Obligation:

Termination digraph:
Nodes:
(1) f56_in(x9:0) -> f56_in(arith) :|: TRUE && arith = x9:0 - 1
(2) f56_in(x1) -> f56_in(x2) :|: x1 > -1 && x2 = x1 - 1

Arcs:
(1) -> (1), (2)
(2) -> (1), (2)

This digraph is fully evaluated!

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

(339) IntTRSCompressionProof (EQUIVALENT)
Compressed rules.
----------------------------------------

(340)
Obligation:
Rules:
f56_in(x9:0:0) -> f56_in(x9:0:0 - 1) :|: TRUE
f56_in(x1:0) -> f56_in(x1:0 - 1) :|: x1:0 > -1

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

(341) TempFilterProof (SOUND)
Used the following sort dictionary for filtering: 
f56_in(VARIABLE)
Replaced non-predefined constructor symbols by 0.The following proof was generated: 
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Termination of the given IntTRS could not be shown:



- IntTRS
  - RankingReductionPairProof

Rules:
f56_in(x9:0:0) -> f56_in(c) :|: c = x9:0:0 - 1 && TRUE
f56_in(x1:0) -> f56_in(c1) :|: c1 = x1:0 - 1 && x1:0 > -1

Interpretation:
[ f56_in ] = f56_in_1 + 1

The following rules are decreasing:
f56_in(x9:0:0) -> f56_in(c) :|: c = x9:0:0 - 1 && TRUE
f56_in(x1:0) -> f56_in(c1) :|: c1 = x1:0 - 1 && x1:0 > -1

The following rules are bounded:
f56_in(x1:0) -> f56_in(c1) :|: c1 = x1:0 - 1 && x1:0 > -1



- IntTRS
  - RankingReductionPairProof
    - IntTRS

Rules:
f56_in(x9:0:0) -> f56_in(c) :|: c = x9:0:0 - 1 && TRUE



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

(342)
Obligation:
Rules:
f56_in(x9:0:0) -> f56_in(x9:0:0 - 1) :|: TRUE

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

(343) IRSwTTerminationDigraphProof (EQUIVALENT)
Constructed termination digraph!
Nodes:
(1) f56_in(x9:0:0) -> f56_in(x9:0:0 - 1) :|: TRUE

Arcs:
(1) -> (1)

This digraph is fully evaluated!
----------------------------------------

(344)
Obligation:

Termination digraph:
Nodes:
(1) f56_in(x9:0:0) -> f56_in(x9:0:0 - 1) :|: TRUE

Arcs:
(1) -> (1)

This digraph is fully evaluated!