WORST_CASE(?,O(n^2))
* Step 1: DependencyPairs WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2} / {0/0,False/0
            ,S/1,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<,bool2Nat,e1,e2,e3,e4,e5,e6,e7,e8,equal0,gcd,help1,l1
            ,l10,l11,l12,l13,l14,l15,l16,l2,l3,l4,l5,l6,l7,l8,l9,m1,m2,m3,m4,m5,monus} and constructors {0,False,S,True}
    + Applied Processor:
        DependencyPairs {dpKind_ = DT}
    + Details:
        We add the following dependency tuples:
        
        Strict DPs
          bool2Nat#(False()) -> c_1()
          bool2Nat#(True()) -> c_2()
          e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          e2#(a,b,res,False()) -> c_4()
          e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          e4#(a,b,res,False()) -> c_7()
          e4#(a,b,res,True()) -> c_8()
          e5#(a,b,res,t) -> c_9()
          e6#(a,b,res,t) -> c_10()
          e7#(a,b,res,t) -> c_11()
          e8#(a,b,res,t) -> c_12()
          equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          help1#(0()) -> c_15()
          help1#(S(0())) -> c_16()
          help1#(S(S(x))) -> c_17()
          l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          l16#(x,y,res,tmp,mtmp,t) -> c_28()
          l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          l6#(x,y,res,tmp,mtmp,t) -> c_35()
          l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          l8#(res,y,res',True(),mtmp,t) -> c_37()
          l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          l9#(res,y,res',tmp,mtmp,t) -> c_39()
          m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          m2#(0(),b,res,True()) -> c_42()
          m2#(S(0()),b,res,True()) -> c_43()
          m2#(S(S(x)),b,res,True()) -> c_44()
          m3#(0(),b,res,t) -> c_45()
          m3#(S(0()),b,res,t) -> c_46()
          m3#(S(S(x)),b,res,t) -> c_47()
          m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          m5#(a,b,res,t) -> c_49()
          monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        Weak DPs
          <#(x,0()) -> c_51()
          <#(0(),S(y)) -> c_52()
          <#(S(x),S(y)) -> c_53(<#(x,y))
        
        and mark the set of starting terms.
* Step 2: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            e2#(a,b,res,False()) -> c_4()
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            m5#(a,b,res,t) -> c_49()
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {1,2,4,7,8,9,10,11,12,15,16,17,28,30,34,35,37,39,42,43,44,45,46,47,49}
        by application of
          Pre({1,2,4,7,8,9,10,11,12,15,16,17,28,30,34,35,37,39,42,43,44,45,46,47,49}) = {3,6,23,24,26,27,36,48}.
        Here rules are labelled as follows:
          1: bool2Nat#(False()) -> c_1()
          2: bool2Nat#(True()) -> c_2()
          3: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          4: e2#(a,b,res,False()) -> c_4()
          5: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          6: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          7: e4#(a,b,res,False()) -> c_7()
          8: e4#(a,b,res,True()) -> c_8()
          9: e5#(a,b,res,t) -> c_9()
          10: e6#(a,b,res,t) -> c_10()
          11: e7#(a,b,res,t) -> c_11()
          12: e8#(a,b,res,t) -> c_12()
          13: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          14: gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          15: help1#(0()) -> c_15()
          16: help1#(S(0())) -> c_16()
          17: help1#(S(S(x))) -> c_17()
          18: l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          19: l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          20: l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          21: l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          22: l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          23: l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          24: l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          25: l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          26: l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          27: l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          28: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          29: l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          30: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          31: l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          32: l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          33: l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          34: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          35: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          36: l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          37: l8#(res,y,res',True(),mtmp,t) -> c_37()
          38: l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          39: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          40: m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          41: m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          42: m2#(0(),b,res,True()) -> c_42()
          43: m2#(S(0()),b,res,True()) -> c_43()
          44: m2#(S(S(x)),b,res,True()) -> c_44()
          45: m3#(0(),b,res,t) -> c_45()
          46: m3#(S(0()),b,res,t) -> c_46()
          47: m3#(S(S(x)),b,res,t) -> c_47()
          48: m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          49: m5#(a,b,res,t) -> c_49()
          50: monus#(a,b) -> c_50(m1#(a,b,False(),False()))
          51: <#(x,0()) -> c_51()
          52: <#(0(),S(y)) -> c_52()
          53: <#(S(x),S(y)) -> c_53(<#(x,y))
* Step 3: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e2#(a,b,res,False()) -> c_4()
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m5#(a,b,res,t) -> c_49()
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {3}
        by application of
          Pre({3}) = {2}.
        Here rules are labelled as follows:
          1: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          2: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          3: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          4: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          5: gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          6: l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          7: l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          8: l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          9: l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          10: l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          11: l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          12: l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          13: l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          14: l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          15: l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          16: l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          17: l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          18: l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          19: l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          20: l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          21: l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          22: m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          23: m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          24: m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          25: monus#(a,b) -> c_50(m1#(a,b,False(),False()))
          26: <#(x,0()) -> c_51()
          27: <#(0(),S(y)) -> c_52()
          28: <#(S(x),S(y)) -> c_53(<#(x,y))
          29: bool2Nat#(False()) -> c_1()
          30: bool2Nat#(True()) -> c_2()
          31: e2#(a,b,res,False()) -> c_4()
          32: e4#(a,b,res,False()) -> c_7()
          33: e4#(a,b,res,True()) -> c_8()
          34: e5#(a,b,res,t) -> c_9()
          35: e6#(a,b,res,t) -> c_10()
          36: e7#(a,b,res,t) -> c_11()
          37: e8#(a,b,res,t) -> c_12()
          38: help1#(0()) -> c_15()
          39: help1#(S(0())) -> c_16()
          40: help1#(S(S(x))) -> c_17()
          41: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          42: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          43: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          44: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          45: l8#(res,y,res',True(),mtmp,t) -> c_37()
          46: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          47: m2#(0(),b,res,True()) -> c_42()
          48: m2#(S(0()),b,res,True()) -> c_43()
          49: m2#(S(S(x)),b,res,True()) -> c_44()
          50: m3#(0(),b,res,t) -> c_45()
          51: m3#(S(0()),b,res,t) -> c_46()
          52: m3#(S(S(x)),b,res,t) -> c_47()
          53: m5#(a,b,res,t) -> c_49()
* Step 4: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e2#(a,b,res,False()) -> c_4()
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m5#(a,b,res,t) -> c_49()
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {2}
        by application of
          Pre({2}) = {1}.
        Here rules are labelled as follows:
          1: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          2: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          3: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          4: gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          5: l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          6: l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          7: l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          8: l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          9: l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          10: l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          11: l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          12: l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          13: l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          14: l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          15: l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          16: l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          17: l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          18: l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          19: l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          20: l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          21: m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          22: m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          23: m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          24: monus#(a,b) -> c_50(m1#(a,b,False(),False()))
          25: <#(x,0()) -> c_51()
          26: <#(0(),S(y)) -> c_52()
          27: <#(S(x),S(y)) -> c_53(<#(x,y))
          28: bool2Nat#(False()) -> c_1()
          29: bool2Nat#(True()) -> c_2()
          30: e2#(a,b,res,False()) -> c_4()
          31: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          32: e4#(a,b,res,False()) -> c_7()
          33: e4#(a,b,res,True()) -> c_8()
          34: e5#(a,b,res,t) -> c_9()
          35: e6#(a,b,res,t) -> c_10()
          36: e7#(a,b,res,t) -> c_11()
          37: e8#(a,b,res,t) -> c_12()
          38: help1#(0()) -> c_15()
          39: help1#(S(0())) -> c_16()
          40: help1#(S(S(x))) -> c_17()
          41: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          42: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          43: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          44: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          45: l8#(res,y,res',True(),mtmp,t) -> c_37()
          46: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          47: m2#(0(),b,res,True()) -> c_42()
          48: m2#(S(0()),b,res,True()) -> c_43()
          49: m2#(S(S(x)),b,res,True()) -> c_44()
          50: m3#(0(),b,res,t) -> c_45()
          51: m3#(S(0()),b,res,t) -> c_46()
          52: m3#(S(S(x)),b,res,t) -> c_47()
          53: m5#(a,b,res,t) -> c_49()
* Step 5: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e2#(a,b,res,False()) -> c_4()
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m5#(a,b,res,t) -> c_49()
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {1}
        by application of
          Pre({1}) = {2}.
        Here rules are labelled as follows:
          1: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          2: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          3: gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          4: l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          5: l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          6: l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          7: l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          8: l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          9: l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          10: l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          11: l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          12: l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          13: l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          14: l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          15: l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          16: l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          17: l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          18: l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          19: l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          20: m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          21: m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          22: m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          23: monus#(a,b) -> c_50(m1#(a,b,False(),False()))
          24: <#(x,0()) -> c_51()
          25: <#(0(),S(y)) -> c_52()
          26: <#(S(x),S(y)) -> c_53(<#(x,y))
          27: bool2Nat#(False()) -> c_1()
          28: bool2Nat#(True()) -> c_2()
          29: e2#(a,b,res,False()) -> c_4()
          30: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          31: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          32: e4#(a,b,res,False()) -> c_7()
          33: e4#(a,b,res,True()) -> c_8()
          34: e5#(a,b,res,t) -> c_9()
          35: e6#(a,b,res,t) -> c_10()
          36: e7#(a,b,res,t) -> c_11()
          37: e8#(a,b,res,t) -> c_12()
          38: help1#(0()) -> c_15()
          39: help1#(S(0())) -> c_16()
          40: help1#(S(S(x))) -> c_17()
          41: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          42: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          43: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          44: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          45: l8#(res,y,res',True(),mtmp,t) -> c_37()
          46: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          47: m2#(0(),b,res,True()) -> c_42()
          48: m2#(S(0()),b,res,True()) -> c_43()
          49: m2#(S(S(x)),b,res,True()) -> c_44()
          50: m3#(0(),b,res,t) -> c_45()
          51: m3#(S(0()),b,res,t) -> c_46()
          52: m3#(S(S(x)),b,res,t) -> c_47()
          53: m5#(a,b,res,t) -> c_49()
* Step 6: PredecessorEstimation WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            e2#(a,b,res,False()) -> c_4()
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m5#(a,b,res,t) -> c_49()
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        PredecessorEstimation {onSelection = all simple predecessor estimation selector}
    + Details:
        We estimate the number of application of
          {1}
        by application of
          Pre({1}) = {17}.
        Here rules are labelled as follows:
          1: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          2: gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          3: l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          4: l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
          5: l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          6: l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          7: l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          8: l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
          9: l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
          10: l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          11: l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
          12: l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
          13: l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          14: l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          15: l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          16: l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          17: l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
          18: l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          19: m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          20: m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          21: m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
          22: monus#(a,b) -> c_50(m1#(a,b,False(),False()))
          23: <#(x,0()) -> c_51()
          24: <#(0(),S(y)) -> c_52()
          25: <#(S(x),S(y)) -> c_53(<#(x,y))
          26: bool2Nat#(False()) -> c_1()
          27: bool2Nat#(True()) -> c_2()
          28: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          29: e2#(a,b,res,False()) -> c_4()
          30: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          31: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          32: e4#(a,b,res,False()) -> c_7()
          33: e4#(a,b,res,True()) -> c_8()
          34: e5#(a,b,res,t) -> c_9()
          35: e6#(a,b,res,t) -> c_10()
          36: e7#(a,b,res,t) -> c_11()
          37: e8#(a,b,res,t) -> c_12()
          38: help1#(0()) -> c_15()
          39: help1#(S(0())) -> c_16()
          40: help1#(S(S(x))) -> c_17()
          41: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          42: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          43: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          44: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          45: l8#(res,y,res',True(),mtmp,t) -> c_37()
          46: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          47: m2#(0(),b,res,True()) -> c_42()
          48: m2#(S(0()),b,res,True()) -> c_43()
          49: m2#(S(S(x)),b,res,True()) -> c_44()
          50: m3#(0(),b,res,t) -> c_45()
          51: m3#(S(0()),b,res,t) -> c_46()
          52: m3#(S(S(x)),b,res,t) -> c_47()
          53: m5#(a,b,res,t) -> c_49()
* Step 7: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            <#(x,0()) -> c_51()
            <#(0(),S(y)) -> c_52()
            <#(S(x),S(y)) -> c_53(<#(x,y))
            bool2Nat#(False()) -> c_1()
            bool2Nat#(True()) -> c_2()
            e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
            e2#(a,b,res,False()) -> c_4()
            e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
            e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
            e4#(a,b,res,False()) -> c_7()
            e4#(a,b,res,True()) -> c_8()
            e5#(a,b,res,t) -> c_9()
            e6#(a,b,res,t) -> c_10()
            e7#(a,b,res,t) -> c_11()
            e8#(a,b,res,t) -> c_12()
            equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
            help1#(0()) -> c_15()
            help1#(S(0())) -> c_16()
            help1#(S(S(x))) -> c_17()
            l16#(x,y,res,tmp,mtmp,t) -> c_28()
            l2#(x,y,res,tmp,mtmp,True()) -> c_30()
            l5#(x,y,res,tmp,mtmp,True()) -> c_34()
            l6#(x,y,res,tmp,mtmp,t) -> c_35()
            l8#(res,y,res',True(),mtmp,t) -> c_37()
            l9#(res,y,res',tmp,mtmp,t) -> c_39()
            m2#(0(),b,res,True()) -> c_42()
            m2#(S(0()),b,res,True()) -> c_43()
            m2#(S(S(x)),b,res,True()) -> c_44()
            m3#(0(),b,res,t) -> c_45()
            m3#(S(0()),b,res,t) -> c_46()
            m3#(S(S(x)),b,res,t) -> c_47()
            m5#(a,b,res,t) -> c_49()
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        RemoveWeakSuffixes
    + Details:
        Consider the dependency graph
          1:S:gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
             -->_1 l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False())):2
          
          2:S:l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
             -->_1 l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False())):12
          
          3:S:l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
             -->_2 <#(S(x),S(y)) -> c_53(<#(x,y)):24
             -->_1 l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True())):5
             -->_1 l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False())):4
             -->_2 <#(0(),S(y)) -> c_52():23
             -->_2 <#(x,0()) -> c_51():22
          
          4:S:l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
             -->_1 l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):9
          
          5:S:l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
             -->_1 l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):6
          
          6:S:l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
             -->_1 l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y)):8
             -->_1 l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y)):7
          
          7:S:l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
             -->_1 l16#(x,y,res,tmp,mtmp,t) -> c_28():41
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          8:S:l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
             -->_1 l16#(x,y,res,tmp,mtmp,t) -> c_28():41
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          9:S:l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
             -->_1 l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0()))):11
             -->_1 l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0())):10
          
          10:S:l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
             -->_1 l16#(x,y,res,tmp,mtmp,t) -> c_28():41
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          11:S:l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
             -->_1 l16#(x,y,res,tmp,mtmp,t) -> c_28():41
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          12:S:l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
             -->_1 l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t)):13
          
          13:S:l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
             -->_1 l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False())):14
          
          14:S:l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
             -->_1 l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False())):15
          
          15:S:l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
             -->_1 l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y)):16
          
          16:S:l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
             -->_2 equal0#(a,b) -> c_13(e1#(a,b,False(),False())):37
             -->_1 l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t)):17
             -->_1 l8#(res,y,res',True(),mtmp,t) -> c_37():45
          
          17:S:l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
             -->_1 l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y)):3
          
          18:S:m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
             -->_1 m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False())):19
          
          19:S:m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
             -->_1 m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x)):20
          
          20:S:m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
             -->_1 m5#(a,b,res,t) -> c_49():53
          
          21:S:monus#(a,b) -> c_50(m1#(a,b,False(),False()))
             -->_1 m1#(a,x,res,t) -> c_40(m2#(a,x,res,False())):18
          
          22:W:<#(x,0()) -> c_51()
             
          
          23:W:<#(0(),S(y)) -> c_52()
             
          
          24:W:<#(S(x),S(y)) -> c_53(<#(x,y))
             -->_1 <#(S(x),S(y)) -> c_53(<#(x,y)):24
             -->_1 <#(0(),S(y)) -> c_52():23
             -->_1 <#(x,0()) -> c_51():22
          
          25:W:bool2Nat#(False()) -> c_1()
             
          
          26:W:bool2Nat#(True()) -> c_2()
             
          
          27:W:e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
             -->_1 e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True())):29
             -->_1 e2#(a,b,res,False()) -> c_4():28
             -->_2 <#(S(x),S(y)) -> c_53(<#(x,y)):24
             -->_2 <#(0(),S(y)) -> c_52():23
             -->_2 <#(x,0()) -> c_51():22
          
          28:W:e2#(a,b,res,False()) -> c_4()
             
          
          29:W:e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
             -->_1 e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a)):30
          
          30:W:e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
             -->_1 e4#(a,b,res,True()) -> c_8():32
             -->_1 e4#(a,b,res,False()) -> c_7():31
             -->_2 <#(S(x),S(y)) -> c_53(<#(x,y)):24
             -->_2 <#(0(),S(y)) -> c_52():23
             -->_2 <#(x,0()) -> c_51():22
          
          31:W:e4#(a,b,res,False()) -> c_7()
             
          
          32:W:e4#(a,b,res,True()) -> c_8()
             
          
          33:W:e5#(a,b,res,t) -> c_9()
             
          
          34:W:e6#(a,b,res,t) -> c_10()
             
          
          35:W:e7#(a,b,res,t) -> c_11()
             
          
          36:W:e8#(a,b,res,t) -> c_12()
             
          
          37:W:equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
             -->_1 e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b)):27
          
          38:W:help1#(0()) -> c_15()
             
          
          39:W:help1#(S(0())) -> c_16()
             
          
          40:W:help1#(S(S(x))) -> c_17()
             
          
          41:W:l16#(x,y,res,tmp,mtmp,t) -> c_28()
             
          
          42:W:l2#(x,y,res,tmp,mtmp,True()) -> c_30()
             
          
          43:W:l5#(x,y,res,tmp,mtmp,True()) -> c_34()
             
          
          44:W:l6#(x,y,res,tmp,mtmp,t) -> c_35()
             
          
          45:W:l8#(res,y,res',True(),mtmp,t) -> c_37()
             
          
          46:W:l9#(res,y,res',tmp,mtmp,t) -> c_39()
             
          
          47:W:m2#(0(),b,res,True()) -> c_42()
             
          
          48:W:m2#(S(0()),b,res,True()) -> c_43()
             
          
          49:W:m2#(S(S(x)),b,res,True()) -> c_44()
             
          
          50:W:m3#(0(),b,res,t) -> c_45()
             
          
          51:W:m3#(S(0()),b,res,t) -> c_46()
             
          
          52:W:m3#(S(S(x)),b,res,t) -> c_47()
             
          
          53:W:m5#(a,b,res,t) -> c_49()
             
          
        The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
          52: m3#(S(S(x)),b,res,t) -> c_47()
          51: m3#(S(0()),b,res,t) -> c_46()
          50: m3#(0(),b,res,t) -> c_45()
          49: m2#(S(S(x)),b,res,True()) -> c_44()
          48: m2#(S(0()),b,res,True()) -> c_43()
          47: m2#(0(),b,res,True()) -> c_42()
          46: l9#(res,y,res',tmp,mtmp,t) -> c_39()
          44: l6#(x,y,res,tmp,mtmp,t) -> c_35()
          43: l5#(x,y,res,tmp,mtmp,True()) -> c_34()
          42: l2#(x,y,res,tmp,mtmp,True()) -> c_30()
          40: help1#(S(S(x))) -> c_17()
          39: help1#(S(0())) -> c_16()
          38: help1#(0()) -> c_15()
          36: e8#(a,b,res,t) -> c_12()
          35: e7#(a,b,res,t) -> c_11()
          34: e6#(a,b,res,t) -> c_10()
          33: e5#(a,b,res,t) -> c_9()
          26: bool2Nat#(True()) -> c_2()
          25: bool2Nat#(False()) -> c_1()
          45: l8#(res,y,res',True(),mtmp,t) -> c_37()
          41: l16#(x,y,res,tmp,mtmp,t) -> c_28()
          53: m5#(a,b,res,t) -> c_49()
          37: equal0#(a,b) -> c_13(e1#(a,b,False(),False()))
          27: e1#(a,b,res,t) -> c_3(e2#(a,b,res,<(a,b)),<#(a,b))
          28: e2#(a,b,res,False()) -> c_4()
          29: e2#(a,b,res,True()) -> c_5(e3#(a,b,res,True()))
          30: e3#(a,b,res,t) -> c_6(e4#(a,b,res,<(b,a)),<#(b,a))
          24: <#(S(x),S(y)) -> c_53(<#(x,y))
          22: <#(x,0()) -> c_51()
          23: <#(0(),S(y)) -> c_52()
          31: e4#(a,b,res,False()) -> c_7()
          32: e4#(a,b,res,True()) -> c_8()
* Step 8: SimplifyRHS WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/2,c_20/1,c_21/1,c_22/2,c_23/2,c_24/2,c_25/2,c_26/2
            ,c_27/2,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/2,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/2,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
             -->_1 l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False())):2
          
          2:S:l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
             -->_1 l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False())):12
          
          3:S:l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y))
             -->_1 l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True())):5
             -->_1 l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False())):4
          
          4:S:l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
             -->_1 l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):9
          
          5:S:l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
             -->_1 l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):6
          
          6:S:l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
             -->_1 l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y)):8
             -->_1 l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y)):7
          
          7:S:l13#(x,y,res,tmp,False(),t) -> c_23(l16#(x,y,gcd(0(),y),tmp,False(),t),gcd#(0(),y))
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          8:S:l13#(x,y,res,tmp,True(),t) -> c_24(l16#(x,y,gcd(S(0()),y),tmp,True(),t),gcd#(S(0()),y))
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          9:S:l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
             -->_1 l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0()))):11
             -->_1 l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0())):10
          
          10:S:l15#(x,y,res,tmp,False(),t) -> c_26(l16#(x,y,gcd(y,0()),tmp,False(),t),gcd#(y,0()))
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          11:S:l15#(x,y,res,tmp,True(),t) -> c_27(l16#(x,y,gcd(y,S(0())),tmp,True(),t),gcd#(y,S(0())))
             -->_2 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          12:S:l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
             -->_1 l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t)):13
          
          13:S:l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
             -->_1 l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False())):14
          
          14:S:l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
             -->_1 l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False())):15
          
          15:S:l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
             -->_1 l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y)):16
          
          16:S:l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t),equal0#(x,y))
             -->_1 l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t)):17
          
          17:S:l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
             -->_1 l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)),<#(x,y)):3
          
          18:S:m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
             -->_1 m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False())):19
          
          19:S:m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
             -->_1 m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x)):20
          
          20:S:m4#(S(x'),S(x),res,t) -> c_48(m5#(S(x'),S(x),monus(x',x),t),monus#(x',x))
             -->_2 monus#(a,b) -> c_50(m1#(a,b,False(),False())):21
          
          21:S:monus#(a,b) -> c_50(m1#(a,b,False(),False()))
             -->_1 m1#(a,x,res,t) -> c_40(m2#(a,x,res,False())):18
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
          l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
          l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
          l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
          l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
          l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
          m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
* Step 9: UsableRules WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            bool2Nat(False()) -> 0()
            bool2Nat(True()) -> S(0())
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            e5(a,b,res,t) -> True()
            e6(a,b,res,t) -> False()
            e7(a,b,res,t) -> False()
            e8(a,b,res,t) -> res
            equal0(a,b) -> e1(a,b,False(),False())
            gcd(x,y) -> l1(x,y,0(),False(),False(),False())
            help1(0()) -> False()
            help1(S(0())) -> False()
            help1(S(S(x))) -> True()
            l1(x,y,res,tmp,mtmp,t) -> l2(x,y,res,tmp,mtmp,False())
            l10(x,y,res,tmp,mtmp,t) -> l11(x,y,res,tmp,mtmp,<(x,y))
            l11(x,y,res,tmp,mtmp,False()) -> l14(x,y,res,tmp,mtmp,False())
            l11(x,y,res,tmp,mtmp,True()) -> l12(x,y,res,tmp,mtmp,True())
            l12(x,y,res,tmp,mtmp,t) -> l13(x,y,res,tmp,monus(x,y),t)
            l13(x,y,res,tmp,False(),t) -> l16(x,y,gcd(0(),y),tmp,False(),t)
            l13(x,y,res,tmp,True(),t) -> l16(x,y,gcd(S(0()),y),tmp,True(),t)
            l14(x,y,res,tmp,mtmp,t) -> l15(x,y,res,tmp,monus(x,y),t)
            l15(x,y,res,tmp,False(),t) -> l16(x,y,gcd(y,0()),tmp,False(),t)
            l15(x,y,res,tmp,True(),t) -> l16(x,y,gcd(y,S(0())),tmp,True(),t)
            l16(x,y,res,tmp,mtmp,t) -> res
            l2(x,y,res,tmp,mtmp,False()) -> l3(x,y,res,tmp,mtmp,False())
            l2(x,y,res,tmp,mtmp,True()) -> res
            l3(x,y,res,tmp,mtmp,t) -> l4(x,y,0(),tmp,mtmp,t)
            l4(x',x,res,tmp,mtmp,t) -> l5(x',x,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,False()) -> l7(x,y,res,tmp,mtmp,False())
            l5(x,y,res,tmp,mtmp,True()) -> 0()
            l6(x,y,res,tmp,mtmp,t) -> 0()
            l7(x,y,res,tmp,mtmp,t) -> l8(x,y,res,equal0(x,y),mtmp,t)
            l8(res,y,res',True(),mtmp,t) -> res
            l8(x,y,res,False(),mtmp,t) -> l10(x,y,res,False(),mtmp,t)
            l9(res,y,res',tmp,mtmp,t) -> res
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m2(0(),b,res,True()) -> False()
            m2(S(0()),b,res,True()) -> False()
            m2(S(S(x)),b,res,True()) -> True()
            m3(0(),b,res,t) -> False()
            m3(S(0()),b,res,t) -> False()
            m3(S(S(x)),b,res,t) -> True()
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        UsableRules
    + Details:
        We replace rewrite rules by usable rules:
          <(x,0()) -> False()
          <(0(),S(y)) -> True()
          <(S(x),S(y)) -> <(x,y)
          e1(a,b,res,t) -> e2(a,b,res,<(a,b))
          e2(a,b,res,False()) -> False()
          e2(a,b,res,True()) -> e3(a,b,res,True())
          e3(a,b,res,t) -> e4(a,b,res,<(b,a))
          e4(a,b,res,False()) -> False()
          e4(a,b,res,True()) -> True()
          equal0(a,b) -> e1(a,b,False(),False())
          m1(a,x,res,t) -> m2(a,x,res,False())
          m2(a,b,res,False()) -> m4(a,b,res,False())
          m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
          m5(a,b,res,t) -> res
          monus(a,b) -> m1(a,b,False(),False())
          gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
          l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
          l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
          l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
          l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
          l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
          l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
          m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
          monus#(a,b) -> c_50(m1#(a,b,False(),False()))
* Step 10: DecomposeDG WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        DecomposeDG {onSelection = all below first cut in WDG, onUpper = Nothing, onLower = Nothing}
    + Details:
        We decompose the input problem according to the dependency graph into the upper component
          gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
          l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
          l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
          l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
          l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
          l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
          l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
          l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
          l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
          l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
          l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
          l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
          l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
          l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
          l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
          l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        and a lower component
          m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
          m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
          m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
          monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        Further, following extension rules are added to the lower component.
          gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
          l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
          l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
          l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
          l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
          l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
          l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
          l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
          l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
          l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
          l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
          l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
          l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
          l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
          l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
          l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
          l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
          l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
          l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
** Step 10.a:1: SimplifyRHS WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        SimplifyRHS
    + Details:
        Consider the dependency graph
          1:S:gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
             -->_1 l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False())):2
          
          2:S:l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
             -->_1 l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False())):12
          
          3:S:l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
             -->_1 l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True())):5
             -->_1 l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False())):4
          
          4:S:l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
             -->_1 l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):9
          
          5:S:l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
             -->_1 l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y)):6
          
          6:S:l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_1 l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y)):8
             -->_1 l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y)):7
          
          7:S:l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
             -->_1 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          8:S:l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
             -->_1 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          9:S:l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t),monus#(x,y))
             -->_1 l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0()))):11
             -->_1 l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0())):10
          
          10:S:l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
             -->_1 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          11:S:l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
             -->_1 gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False())):1
          
          12:S:l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
             -->_1 l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t)):13
          
          13:S:l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
             -->_1 l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False())):14
          
          14:S:l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
             -->_1 l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False())):15
          
          15:S:l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
             -->_1 l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t)):16
          
          16:S:l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
             -->_1 l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t)):17
          
          17:S:l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
             -->_1 l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y))):3
          
        Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
          l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
          l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
** Step 10.a:2: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [2]                                    
                    p(<) = [0]                                    
                p(False) = [0]                                    
                    p(S) = [0]                                    
                 p(True) = [0]                                    
             p(bool2Nat) = [1] x1 + [2]                           
                   p(e1) = [1] x3 + [0]                           
                   p(e2) = [1] x3 + [1] x4 + [0]                  
                   p(e3) = [0]                                    
                   p(e4) = [1] x4 + [0]                           
                   p(e5) = [0]                                    
                   p(e6) = [0]                                    
                   p(e7) = [0]                                    
                   p(e8) = [0]                                    
               p(equal0) = [5]                                    
                  p(gcd) = [0]                                    
                p(help1) = [0]                                    
                   p(l1) = [0]                                    
                  p(l10) = [0]                                    
                  p(l11) = [0]                                    
                  p(l12) = [0]                                    
                  p(l13) = [0]                                    
                  p(l14) = [0]                                    
                  p(l15) = [0]                                    
                  p(l16) = [0]                                    
                   p(l2) = [0]                                    
                   p(l3) = [0]                                    
                   p(l4) = [0]                                    
                   p(l5) = [0]                                    
                   p(l6) = [0]                                    
                   p(l7) = [0]                                    
                   p(l8) = [0]                                    
                   p(l9) = [0]                                    
                   p(m1) = [1] x3 + [0]                           
                   p(m2) = [1] x3 + [0]                           
                   p(m3) = [0]                                    
                   p(m4) = [0]                                    
                   p(m5) = [1] x2 + [1] x3 + [0]                  
                p(monus) = [0]                                    
                   p(<#) = [0]                                    
            p(bool2Nat#) = [0]                                    
                  p(e1#) = [0]                                    
                  p(e2#) = [0]                                    
                  p(e3#) = [0]                                    
                  p(e4#) = [0]                                    
                  p(e5#) = [0]                                    
                  p(e6#) = [0]                                    
                  p(e7#) = [0]                                    
                  p(e8#) = [0]                                    
              p(equal0#) = [0]                                    
                 p(gcd#) = [5]                                    
               p(help1#) = [0]                                    
                  p(l1#) = [3] x3 + [1] x4 + [7] x5 + [1] x6 + [4]
                 p(l10#) = [2] x3 + [2] x5 + [3]                  
                 p(l11#) = [2] x5 + [1] x6 + [3]                  
                 p(l12#) = [2] x5 + [2]                           
                 p(l13#) = [1] x5 + [7]                           
                 p(l14#) = [2] x5 + [2]                           
                 p(l15#) = [1] x5 + [0]                           
                 p(l16#) = [0]                                    
                  p(l2#) = [1] x4 + [4] x5 + [4]                  
                  p(l3#) = [4] x5 + [3]                           
                  p(l4#) = [2] x3 + [4] x5 + [0]                  
                  p(l5#) = [2] x3 + [4] x5 + [0]                  
                  p(l6#) = [0]                                    
                  p(l7#) = [2] x3 + [4] x5 + [7]                  
                  p(l8#) = [2] x3 + [1] x4 + [2] x5 + [0]         
                  p(l9#) = [0]                                    
                  p(m1#) = [0]                                    
                  p(m2#) = [2] x2 + [0]                           
                  p(m3#) = [0]                                    
                  p(m4#) = [0]                                    
                  p(m5#) = [2] x2 + [0]                           
               p(monus#) = [2] x2 + [0]                           
                  p(c_1) = [4]                                    
                  p(c_2) = [1]                                    
                  p(c_3) = [1] x2 + [0]                           
                  p(c_4) = [1]                                    
                  p(c_5) = [0]                                    
                  p(c_6) = [2]                                    
                  p(c_7) = [0]                                    
                  p(c_8) = [0]                                    
                  p(c_9) = [0]                                    
                 p(c_10) = [0]                                    
                 p(c_11) = [0]                                    
                 p(c_12) = [0]                                    
                 p(c_13) = [0]                                    
                 p(c_14) = [1] x1 + [0]                           
                 p(c_15) = [0]                                    
                 p(c_16) = [0]                                    
                 p(c_17) = [0]                                    
                 p(c_18) = [1] x1 + [7]                           
                 p(c_19) = [1] x1 + [0]                           
                 p(c_20) = [1] x1 + [3]                           
                 p(c_21) = [1] x1 + [3]                           
                 p(c_22) = [1] x1 + [0]                           
                 p(c_23) = [1] x1 + [0]                           
                 p(c_24) = [1] x1 + [3]                           
                 p(c_25) = [1] x1 + [0]                           
                 p(c_26) = [1] x1 + [0]                           
                 p(c_27) = [1] x1 + [0]                           
                 p(c_28) = [0]                                    
                 p(c_29) = [1] x1 + [7]                           
                 p(c_30) = [0]                                    
                 p(c_31) = [1] x1 + [1]                           
                 p(c_32) = [1] x1 + [0]                           
                 p(c_33) = [1] x1 + [0]                           
                 p(c_34) = [0]                                    
                 p(c_35) = [0]                                    
                 p(c_36) = [1] x1 + [0]                           
                 p(c_37) = [0]                                    
                 p(c_38) = [1] x1 + [0]                           
                 p(c_39) = [0]                                    
                 p(c_40) = [0]                                    
                 p(c_41) = [0]                                    
                 p(c_42) = [0]                                    
                 p(c_43) = [0]                                    
                 p(c_44) = [0]                                    
                 p(c_45) = [0]                                    
                 p(c_46) = [0]                                    
                 p(c_47) = [0]                                    
                 p(c_48) = [0]                                    
                 p(c_49) = [0]                                    
                 p(c_50) = [0]                                    
                 p(c_51) = [0]                                    
                 p(c_52) = [0]                                    
                 p(c_53) = [0]                                    
          
          Following rules are strictly oriented:
          l13#(x,y,res,tmp,False(),t) = [7]                                  
                                      > [5]                                  
                                      = c_23(gcd#(0(),y))                    
          
             l14#(x,y,res,tmp,mtmp,t) = [2] mtmp + [2]                       
                                      > [0]                                  
                                      = c_25(l15#(x,y,res,tmp,monus(x,y),t)) 
          
              l7#(x,y,res,tmp,mtmp,t) = [4] mtmp + [2] res + [7]             
                                      > [2] mtmp + [2] res + [5]             
                                      = c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [5]                                       
                                         >= [10]                                      
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [7] mtmp + [3] res + [1] t + [1] tmp + [4]
                                         >= [4] mtmp + [1] tmp + [11]                 
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [2] mtmp + [2] res + [3]                  
                                         >= [2] mtmp + [3]                            
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [2] mtmp + [3]                            
                                         >= [2] mtmp + [5]                            
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [2] mtmp + [3]                            
                                         >= [2] mtmp + [5]                            
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [2] mtmp + [2]                            
                                         >= [7]                                       
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
              l13#(x,y,res,tmp,True(),t) =  [7]                                       
                                         >= [8]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
             l15#(x,y,res,tmp,False(),t) =  [0]                                       
                                         >= [5]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [0]                                       
                                         >= [5]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [4] mtmp + [1] tmp + [4]                  
                                         >= [4] mtmp + [10]                           
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [4] mtmp + [3]                            
                                         >= [4] mtmp + [5]                            
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [4] mtmp + [2] res + [0]                  
                                         >= [4] mtmp + [2] res + [0]                  
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [4] mtmp + [2] res + [0]                  
                                         >= [4] mtmp + [2] res + [7]                  
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
             l8#(x,y,res,False(),mtmp,t) =  [2] mtmp + [2] res + [0]                  
                                         >= [2] mtmp + [2] res + [3]                  
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [1] res + [0]                             
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [1] res + [0]                             
                                         >= [0]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [5]                                       
                                         >= [0]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [1] res + [0]                             
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] b + [1] res + [0]                     
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:3: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak DPs:
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                  
                    p(<) = [0]                  
                p(False) = [0]                  
                    p(S) = [0]                  
                 p(True) = [0]                  
             p(bool2Nat) = [1] x1 + [2]         
                   p(e1) = [4] x3 + [1] x4 + [6]
                   p(e2) = [4] x3 + [1] x4 + [6]
                   p(e3) = [6]                  
                   p(e4) = [1] x4 + [0]         
                   p(e5) = [0]                  
                   p(e6) = [0]                  
                   p(e7) = [0]                  
                   p(e8) = [0]                  
               p(equal0) = [6]                  
                  p(gcd) = [0]                  
                p(help1) = [0]                  
                   p(l1) = [0]                  
                  p(l10) = [0]                  
                  p(l11) = [0]                  
                  p(l12) = [0]                  
                  p(l13) = [0]                  
                  p(l14) = [0]                  
                  p(l15) = [0]                  
                  p(l16) = [0]                  
                   p(l2) = [0]                  
                   p(l3) = [1] x2 + [0]         
                   p(l4) = [1]                  
                   p(l5) = [0]                  
                   p(l6) = [0]                  
                   p(l7) = [0]                  
                   p(l8) = [0]                  
                   p(l9) = [0]                  
                   p(m1) = [0]                  
                   p(m2) = [0]                  
                   p(m3) = [0]                  
                   p(m4) = [0]                  
                   p(m5) = [1] x3 + [0]         
                p(monus) = [0]                  
                   p(<#) = [0]                  
            p(bool2Nat#) = [0]                  
                  p(e1#) = [0]                  
                  p(e2#) = [0]                  
                  p(e3#) = [0]                  
                  p(e4#) = [0]                  
                  p(e5#) = [0]                  
                  p(e6#) = [0]                  
                  p(e7#) = [0]                  
                  p(e8#) = [0]                  
              p(equal0#) = [0]                  
                 p(gcd#) = [0]                  
               p(help1#) = [1] x1 + [0]         
                  p(l1#) = [4] x3 + [4] x4 + [0]
                 p(l10#) = [0]                  
                 p(l11#) = [1] x6 + [0]         
                 p(l12#) = [0]                  
                 p(l13#) = [1] x5 + [0]         
                 p(l14#) = [0]                  
                 p(l15#) = [1] x5 + [0]         
                 p(l16#) = [0]                  
                  p(l2#) = [4] x3 + [4] x4 + [5]
                  p(l3#) = [1] x4 + [1] x6 + [4]
                  p(l4#) = [0]                  
                  p(l5#) = [0]                  
                  p(l6#) = [2] x5 + [2] x6 + [0]
                  p(l7#) = [7]                  
                  p(l8#) = [1] x4 + [1]         
                  p(l9#) = [0]                  
                  p(m1#) = [0]                  
                  p(m2#) = [0]                  
                  p(m3#) = [0]                  
                  p(m4#) = [2] x2 + [0]         
                  p(m5#) = [0]                  
               p(monus#) = [0]                  
                  p(c_1) = [0]                  
                  p(c_2) = [0]                  
                  p(c_3) = [0]                  
                  p(c_4) = [0]                  
                  p(c_5) = [0]                  
                  p(c_6) = [0]                  
                  p(c_7) = [0]                  
                  p(c_8) = [0]                  
                  p(c_9) = [0]                  
                 p(c_10) = [0]                  
                 p(c_11) = [0]                  
                 p(c_12) = [0]                  
                 p(c_13) = [0]                  
                 p(c_14) = [1] x1 + [0]         
                 p(c_15) = [0]                  
                 p(c_16) = [0]                  
                 p(c_17) = [0]                  
                 p(c_18) = [1] x1 + [0]         
                 p(c_19) = [1] x1 + [0]         
                 p(c_20) = [1] x1 + [0]         
                 p(c_21) = [1] x1 + [0]         
                 p(c_22) = [1] x1 + [0]         
                 p(c_23) = [1] x1 + [0]         
                 p(c_24) = [1] x1 + [0]         
                 p(c_25) = [1] x1 + [0]         
                 p(c_26) = [1] x1 + [0]         
                 p(c_27) = [1] x1 + [0]         
                 p(c_28) = [0]                  
                 p(c_29) = [1] x1 + [0]         
                 p(c_30) = [0]                  
                 p(c_31) = [1] x1 + [0]         
                 p(c_32) = [1] x1 + [0]         
                 p(c_33) = [1] x1 + [0]         
                 p(c_34) = [0]                  
                 p(c_35) = [0]                  
                 p(c_36) = [1] x1 + [0]         
                 p(c_37) = [0]                  
                 p(c_38) = [1] x1 + [0]         
                 p(c_39) = [0]                  
                 p(c_40) = [0]                  
                 p(c_41) = [0]                  
                 p(c_42) = [0]                  
                 p(c_43) = [0]                  
                 p(c_44) = [0]                  
                 p(c_45) = [0]                  
                 p(c_46) = [0]                  
                 p(c_47) = [0]                  
                 p(c_48) = [0]                  
                 p(c_49) = [0]                  
                 p(c_50) = [0]                  
                 p(c_51) = [0]                  
                 p(c_52) = [0]                  
                 p(c_53) = [0]                  
          
          Following rules are strictly oriented:
          l2#(x,y,res,tmp,mtmp,False()) = [4] res + [4] tmp + [5]            
                                        > [1] tmp + [4]                      
                                        = c_29(l3#(x,y,res,tmp,mtmp,False()))
          
                l3#(x,y,res,tmp,mtmp,t) = [1] t + [1] tmp + [4]              
                                        > [0]                                
                                        = c_31(l4#(x,y,0(),tmp,mtmp,t))      
          
            l8#(x,y,res,False(),mtmp,t) = [1]                                
                                        > [0]                                
                                        = c_38(l10#(x,y,res,False(),mtmp,t)) 
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                       
                                         >= [0]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [4] res + [4] tmp + [0]                   
                                         >= [4] res + [4] tmp + [5]                   
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
                l4#(x',x,res,tmp,mtmp,t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [0]                                       
                                         >= [7]                                       
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [7]                                       
                                         >= [7]                                       
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [4] res + [1] t + [6]                     
                                         >= [4] res + [6]                             
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [4] res + [6]                             
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [4] res + [6]                             
                                         >= [6]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [6]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [6]                                       
                                         >= [6]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:4: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                  
                    p(<) = [0]                  
                p(False) = [0]                  
                    p(S) = [1] x1 + [1]         
                 p(True) = [0]                  
             p(bool2Nat) = [2] x1 + [0]         
                   p(e1) = [2] x3 + [2] x4 + [2]
                   p(e2) = [1] x4 + [2]         
                   p(e3) = [1]                  
                   p(e4) = [1] x4 + [1]         
                   p(e5) = [0]                  
                   p(e6) = [0]                  
                   p(e7) = [0]                  
                   p(e8) = [0]                  
               p(equal0) = [2]                  
                  p(gcd) = [0]                  
                p(help1) = [0]                  
                   p(l1) = [0]                  
                  p(l10) = [0]                  
                  p(l11) = [0]                  
                  p(l12) = [0]                  
                  p(l13) = [0]                  
                  p(l14) = [0]                  
                  p(l15) = [0]                  
                  p(l16) = [0]                  
                   p(l2) = [0]                  
                   p(l3) = [0]                  
                   p(l4) = [0]                  
                   p(l5) = [0]                  
                   p(l6) = [0]                  
                   p(l7) = [0]                  
                   p(l8) = [0]                  
                   p(l9) = [0]                  
                   p(m1) = [0]                  
                   p(m2) = [0]                  
                   p(m3) = [0]                  
                   p(m4) = [0]                  
                   p(m5) = [1] x3 + [0]         
                p(monus) = [0]                  
                   p(<#) = [0]                  
            p(bool2Nat#) = [0]                  
                  p(e1#) = [0]                  
                  p(e2#) = [0]                  
                  p(e3#) = [0]                  
                  p(e4#) = [0]                  
                  p(e5#) = [0]                  
                  p(e6#) = [0]                  
                  p(e7#) = [0]                  
                  p(e8#) = [0]                  
              p(equal0#) = [0]                  
                 p(gcd#) = [0]                  
               p(help1#) = [0]                  
                  p(l1#) = [2] x4 + [5]         
                 p(l10#) = [1] x4 + [3]         
                 p(l11#) = [1] x6 + [3]         
                 p(l12#) = [5]                  
                 p(l13#) = [1] x5 + [7]         
                 p(l14#) = [1]                  
                 p(l15#) = [1] x5 + [1]         
                 p(l16#) = [0]                  
                  p(l2#) = [2] x4 + [7]         
                  p(l3#) = [3]                  
                  p(l4#) = [4] x3 + [0]         
                  p(l5#) = [4] x3 + [3]         
                  p(l6#) = [1] x5 + [0]         
                  p(l7#) = [2] x3 + [5]         
                  p(l8#) = [2] x3 + [1] x4 + [3]
                  p(l9#) = [0]                  
                  p(m1#) = [0]                  
                  p(m2#) = [0]                  
                  p(m3#) = [0]                  
                  p(m4#) = [0]                  
                  p(m5#) = [2] x4 + [0]         
               p(monus#) = [0]                  
                  p(c_1) = [0]                  
                  p(c_2) = [0]                  
                  p(c_3) = [2] x1 + [0]         
                  p(c_4) = [0]                  
                  p(c_5) = [0]                  
                  p(c_6) = [0]                  
                  p(c_7) = [0]                  
                  p(c_8) = [0]                  
                  p(c_9) = [0]                  
                 p(c_10) = [0]                  
                 p(c_11) = [0]                  
                 p(c_12) = [0]                  
                 p(c_13) = [0]                  
                 p(c_14) = [1] x1 + [0]         
                 p(c_15) = [0]                  
                 p(c_16) = [0]                  
                 p(c_17) = [0]                  
                 p(c_18) = [1] x1 + [2]         
                 p(c_19) = [1] x1 + [0]         
                 p(c_20) = [1] x1 + [0]         
                 p(c_21) = [1] x1 + [0]         
                 p(c_22) = [1] x1 + [4]         
                 p(c_23) = [1] x1 + [7]         
                 p(c_24) = [1] x1 + [1]         
                 p(c_25) = [1] x1 + [0]         
                 p(c_26) = [1] x1 + [1]         
                 p(c_27) = [1] x1 + [0]         
                 p(c_28) = [0]                  
                 p(c_29) = [1] x1 + [4]         
                 p(c_30) = [0]                  
                 p(c_31) = [1] x1 + [3]         
                 p(c_32) = [1] x1 + [0]         
                 p(c_33) = [1] x1 + [3]         
                 p(c_34) = [0]                  
                 p(c_35) = [1]                  
                 p(c_36) = [1] x1 + [0]         
                 p(c_37) = [0]                  
                 p(c_38) = [1] x1 + [0]         
                 p(c_39) = [0]                  
                 p(c_40) = [0]                  
                 p(c_41) = [0]                  
                 p(c_42) = [0]                  
                 p(c_43) = [0]                  
                 p(c_44) = [0]                  
                 p(c_45) = [0]                  
                 p(c_46) = [0]                  
                 p(c_47) = [0]                  
                 p(c_48) = [0]                  
                 p(c_49) = [0]                  
                 p(c_50) = [0]                  
                 p(c_51) = [0]                  
                 p(c_52) = [0]                  
                 p(c_53) = [0]                  
          
          Following rules are strictly oriented:
          l11#(x,y,res,tmp,mtmp,False()) = [3]                                 
                                         > [1]                                 
                                         = c_20(l14#(x,y,res,tmp,mtmp,False()))
          
              l13#(x,y,res,tmp,True(),t) = [7]                                 
                                         > [1]                                 
                                         = c_24(gcd#(S(0()),y))                
          
              l15#(x,y,res,tmp,True(),t) = [1]                                 
                                         > [0]                                 
                                         = c_27(gcd#(y,S(0())))                
          
          
          Following rules are (at-least) weakly oriented:
                              gcd#(x,y) =  [0]                                       
                                        >= [5]                                       
                                        =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                l1#(x,y,res,tmp,mtmp,t) =  [2] tmp + [5]                             
                                        >= [2] tmp + [9]                             
                                        =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
               l10#(x,y,res,tmp,mtmp,t) =  [1] tmp + [3]                             
                                        >= [3]                                       
                                        =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,True()) =  [3]                                       
                                        >= [5]                                       
                                        =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
               l12#(x,y,res,tmp,mtmp,t) =  [5]                                       
                                        >= [11]                                      
                                        =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
            l13#(x,y,res,tmp,False(),t) =  [7]                                       
                                        >= [7]                                       
                                        =  c_23(gcd#(0(),y))                         
          
               l14#(x,y,res,tmp,mtmp,t) =  [1]                                       
                                        >= [1]                                       
                                        =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
            l15#(x,y,res,tmp,False(),t) =  [1]                                       
                                        >= [1]                                       
                                        =  c_26(gcd#(y,0()))                         
          
          l2#(x,y,res,tmp,mtmp,False()) =  [2] tmp + [7]                             
                                        >= [7]                                       
                                        =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                l3#(x,y,res,tmp,mtmp,t) =  [3]                                       
                                        >= [3]                                       
                                        =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
               l4#(x',x,res,tmp,mtmp,t) =  [4] res + [0]                             
                                        >= [4] res + [3]                             
                                        =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
          l5#(x,y,res,tmp,mtmp,False()) =  [4] res + [3]                             
                                        >= [2] res + [8]                             
                                        =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                l7#(x,y,res,tmp,mtmp,t) =  [2] res + [5]                             
                                        >= [2] res + [5]                             
                                        =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
            l8#(x,y,res,False(),mtmp,t) =  [2] res + [3]                             
                                        >= [3]                                       
                                        =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                               <(x,0()) =  [0]                                       
                                        >= [0]                                       
                                        =  False()                                   
          
                            <(0(),S(y)) =  [0]                                       
                                        >= [0]                                       
                                        =  True()                                    
          
                           <(S(x),S(y)) =  [0]                                       
                                        >= [0]                                       
                                        =  <(x,y)                                    
          
                          e1(a,b,res,t) =  [2] res + [2] t + [2]                     
                                        >= [2]                                       
                                        =  e2(a,b,res,<(a,b))                        
          
                    e2(a,b,res,False()) =  [2]                                       
                                        >= [0]                                       
                                        =  False()                                   
          
                     e2(a,b,res,True()) =  [2]                                       
                                        >= [1]                                       
                                        =  e3(a,b,res,True())                        
          
                          e3(a,b,res,t) =  [1]                                       
                                        >= [1]                                       
                                        =  e4(a,b,res,<(b,a))                        
          
                    e4(a,b,res,False()) =  [1]                                       
                                        >= [0]                                       
                                        =  False()                                   
          
                     e4(a,b,res,True()) =  [1]                                       
                                        >= [0]                                       
                                        =  True()                                    
          
                            equal0(a,b) =  [2]                                       
                                        >= [2]                                       
                                        =  e1(a,b,False(),False())                   
          
                          m1(a,x,res,t) =  [0]                                       
                                        >= [0]                                       
                                        =  m2(a,x,res,False())                       
          
                    m2(a,b,res,False()) =  [0]                                       
                                        >= [0]                                       
                                        =  m4(a,b,res,False())                       
          
                   m4(S(x'),S(x),res,t) =  [0]                                       
                                        >= [0]                                       
                                        =  m5(S(x'),S(x),monus(x',x),t)              
          
                          m5(a,b,res,t) =  [1] res + [0]                             
                                        >= [1] res + [0]                             
                                        =  res                                       
          
                             monus(a,b) =  [0]                                       
                                        >= [0]                                       
                                        =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:5: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                  
                    p(<) = [2]                  
                p(False) = [2]                  
                    p(S) = [1] x1 + [0]         
                 p(True) = [2]                  
             p(bool2Nat) = [0]                  
                   p(e1) = [3]                  
                   p(e2) = [1] x4 + [0]         
                   p(e3) = [2]                  
                   p(e4) = [1] x4 + [0]         
                   p(e5) = [2] x2 + [0]         
                   p(e6) = [0]                  
                   p(e7) = [0]                  
                   p(e8) = [0]                  
               p(equal0) = [3]                  
                  p(gcd) = [0]                  
                p(help1) = [0]                  
                   p(l1) = [0]                  
                  p(l10) = [0]                  
                  p(l11) = [0]                  
                  p(l12) = [0]                  
                  p(l13) = [0]                  
                  p(l14) = [2]                  
                  p(l15) = [0]                  
                  p(l16) = [0]                  
                   p(l2) = [0]                  
                   p(l3) = [0]                  
                   p(l4) = [0]                  
                   p(l5) = [0]                  
                   p(l6) = [0]                  
                   p(l7) = [0]                  
                   p(l8) = [0]                  
                   p(l9) = [0]                  
                   p(m1) = [0]                  
                   p(m2) = [0]                  
                   p(m3) = [0]                  
                   p(m4) = [0]                  
                   p(m5) = [1] x3 + [0]         
                p(monus) = [0]                  
                   p(<#) = [0]                  
            p(bool2Nat#) = [0]                  
                  p(e1#) = [0]                  
                  p(e2#) = [2] x1 + [0]         
                  p(e3#) = [0]                  
                  p(e4#) = [0]                  
                  p(e5#) = [0]                  
                  p(e6#) = [0]                  
                  p(e7#) = [0]                  
                  p(e8#) = [0]                  
              p(equal0#) = [0]                  
                 p(gcd#) = [4]                  
               p(help1#) = [2]                  
                  p(l1#) = [4] x3 + [1] x4 + [7]
                 p(l10#) = [1]                  
                 p(l11#) = [1] x6 + [6]         
                 p(l12#) = [1] x6 + [0]         
                 p(l13#) = [1] x5 + [5]         
                 p(l14#) = [3] x6 + [2]         
                 p(l15#) = [1] x5 + [3] x6 + [2]
                 p(l16#) = [0]                  
                  p(l2#) = [4] x3 + [1] x4 + [6]
                  p(l3#) = [1] x4 + [1] x6 + [0]
                  p(l4#) = [5] x3 + [1] x4 + [0]
                  p(l5#) = [5] x3 + [1] x4 + [1]
                  p(l6#) = [0]                  
                  p(l7#) = [4] x3 + [7]         
                  p(l8#) = [1] x3 + [1] x4 + [4]
                  p(l9#) = [0]                  
                  p(m1#) = [0]                  
                  p(m2#) = [0]                  
                  p(m3#) = [0]                  
                  p(m4#) = [0]                  
                  p(m5#) = [0]                  
               p(monus#) = [0]                  
                  p(c_1) = [0]                  
                  p(c_2) = [0]                  
                  p(c_3) = [2] x2 + [0]         
                  p(c_4) = [0]                  
                  p(c_5) = [2] x1 + [0]         
                  p(c_6) = [1] x2 + [2]         
                  p(c_7) = [1]                  
                  p(c_8) = [0]                  
                  p(c_9) = [1]                  
                 p(c_10) = [1]                  
                 p(c_11) = [1]                  
                 p(c_12) = [0]                  
                 p(c_13) = [0]                  
                 p(c_14) = [1] x1 + [0]         
                 p(c_15) = [4]                  
                 p(c_16) = [0]                  
                 p(c_17) = [0]                  
                 p(c_18) = [1] x1 + [5]         
                 p(c_19) = [1] x1 + [0]         
                 p(c_20) = [1] x1 + [0]         
                 p(c_21) = [1] x1 + [4]         
                 p(c_22) = [1] x1 + [5]         
                 p(c_23) = [1] x1 + [0]         
                 p(c_24) = [1] x1 + [3]         
                 p(c_25) = [1] x1 + [0]         
                 p(c_26) = [1] x1 + [2]         
                 p(c_27) = [1] x1 + [0]         
                 p(c_28) = [4]                  
                 p(c_29) = [1] x1 + [4]         
                 p(c_30) = [1]                  
                 p(c_31) = [1] x1 + [0]         
                 p(c_32) = [1] x1 + [4]         
                 p(c_33) = [1] x1 + [0]         
                 p(c_34) = [1]                  
                 p(c_35) = [4]                  
                 p(c_36) = [1] x1 + [0]         
                 p(c_37) = [0]                  
                 p(c_38) = [1] x1 + [5]         
                 p(c_39) = [2]                  
                 p(c_40) = [4]                  
                 p(c_41) = [1] x1 + [1]         
                 p(c_42) = [1]                  
                 p(c_43) = [0]                  
                 p(c_44) = [1]                  
                 p(c_45) = [1]                  
                 p(c_46) = [0]                  
                 p(c_47) = [4]                  
                 p(c_48) = [1]                  
                 p(c_49) = [1]                  
                 p(c_50) = [1] x1 + [0]         
                 p(c_51) = [0]                  
                 p(c_52) = [1]                  
                 p(c_53) = [1]                  
          
          Following rules are strictly oriented:
          l11#(x,y,res,tmp,mtmp,True()) = [8]                                
                                        > [6]                                
                                        = c_21(l12#(x,y,res,tmp,mtmp,True()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [4]                                       
                                         >= [9]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [4] res + [1] tmp + [7]                   
                                         >= [4] res + [1] tmp + [11]                  
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [1]                                       
                                         >= [8]                                       
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [8]                                       
                                         >= [8]                                       
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
                l12#(x,y,res,tmp,mtmp,t) =  [1] t + [0]                               
                                         >= [10]                                      
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [7]                                       
                                         >= [4]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [7]                                       
                                         >= [7]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [3] t + [2]                               
                                         >= [3] t + [2]                               
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [3] t + [4]                               
                                         >= [6]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [3] t + [4]                               
                                         >= [4]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [4] res + [1] tmp + [6]                   
                                         >= [1] tmp + [6]                             
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1] t + [1] tmp + [0]                     
                                         >= [1] tmp + [0]                             
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [5] res + [1] tmp + [0]                   
                                         >= [5] res + [1] tmp + [5]                   
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [5] res + [1] tmp + [1]                   
                                         >= [4] res + [7]                             
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [4] res + [7]                             
                                         >= [1] res + [7]                             
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [1] res + [6]                             
                                         >= [6]                                       
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [2]                                       
                                         >= [2]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [2]                                       
                                         >= [2]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [2]                                       
                                         >= [2]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [3]                                       
                                         >= [2]                                       
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [2]                                       
                                         >= [2]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [2]                                       
                                         >= [2]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [2]                                       
                                         >= [2]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [2]                                       
                                         >= [2]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [2]                                       
                                         >= [2]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [3]                                       
                                         >= [3]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:6: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [1]                           
                    p(<) = [0]                           
                p(False) = [0]                           
                    p(S) = [0]                           
                 p(True) = [0]                           
             p(bool2Nat) = [1]                           
                   p(e1) = [1] x3 + [1]                  
                   p(e2) = [1] x3 + [1] x4 + [1]         
                   p(e3) = [0]                           
                   p(e4) = [1] x4 + [0]                  
                   p(e5) = [0]                           
                   p(e6) = [2] x3 + [0]                  
                   p(e7) = [0]                           
                   p(e8) = [0]                           
               p(equal0) = [1]                           
                  p(gcd) = [0]                           
                p(help1) = [0]                           
                   p(l1) = [0]                           
                  p(l10) = [0]                           
                  p(l11) = [0]                           
                  p(l12) = [0]                           
                  p(l13) = [0]                           
                  p(l14) = [0]                           
                  p(l15) = [0]                           
                  p(l16) = [2] x3 + [0]                  
                   p(l2) = [0]                           
                   p(l3) = [0]                           
                   p(l4) = [2]                           
                   p(l5) = [0]                           
                   p(l6) = [0]                           
                   p(l7) = [0]                           
                   p(l8) = [0]                           
                   p(l9) = [0]                           
                   p(m1) = [4] x3 + [0]                  
                   p(m2) = [0]                           
                   p(m3) = [0]                           
                   p(m4) = [5] x4 + [0]                  
                   p(m5) = [1] x3 + [0]                  
                p(monus) = [0]                           
                   p(<#) = [0]                           
            p(bool2Nat#) = [0]                           
                  p(e1#) = [0]                           
                  p(e2#) = [0]                           
                  p(e3#) = [0]                           
                  p(e4#) = [0]                           
                  p(e5#) = [2] x4 + [0]                  
                  p(e6#) = [0]                           
                  p(e7#) = [0]                           
                  p(e8#) = [0]                           
              p(equal0#) = [0]                           
                 p(gcd#) = [0]                           
               p(help1#) = [0]                           
                  p(l1#) = [1] x4 + [2] x5 + [1]         
                 p(l10#) = [1] x3 + [3] x4 + [0]         
                 p(l11#) = [2] x4 + [1] x6 + [7]         
                 p(l12#) = [2] x4 + [4] x6 + [0]         
                 p(l13#) = [1] x5 + [4] x6 + [4]         
                 p(l14#) = [1] x6 + [4]                  
                 p(l15#) = [1] x5 + [1] x6 + [4]         
                 p(l16#) = [2] x3 + [2] x6 + [0]         
                  p(l2#) = [1] x5 + [1] x6 + [6]         
                  p(l3#) = [5]                           
                  p(l4#) = [4] x3 + [1]                  
                  p(l5#) = [4] x3 + [5]                  
                  p(l6#) = [2] x4 + [1] x5 + [0]         
                  p(l7#) = [3] x3 + [4] x6 + [1]         
                  p(l8#) = [2] x3 + [1] x4 + [1] x6 + [0]
                  p(l9#) = [0]                           
                  p(m1#) = [0]                           
                  p(m2#) = [0]                           
                  p(m3#) = [0]                           
                  p(m4#) = [0]                           
                  p(m5#) = [0]                           
               p(monus#) = [0]                           
                  p(c_1) = [0]                           
                  p(c_2) = [0]                           
                  p(c_3) = [0]                           
                  p(c_4) = [0]                           
                  p(c_5) = [0]                           
                  p(c_6) = [0]                           
                  p(c_7) = [0]                           
                  p(c_8) = [0]                           
                  p(c_9) = [0]                           
                 p(c_10) = [0]                           
                 p(c_11) = [0]                           
                 p(c_12) = [0]                           
                 p(c_13) = [1]                           
                 p(c_14) = [1] x1 + [2]                  
                 p(c_15) = [4]                           
                 p(c_16) = [1]                           
                 p(c_17) = [2]                           
                 p(c_18) = [1] x1 + [0]                  
                 p(c_19) = [1] x1 + [0]                  
                 p(c_20) = [1] x1 + [3]                  
                 p(c_21) = [1] x1 + [0]                  
                 p(c_22) = [1] x1 + [7]                  
                 p(c_23) = [1] x1 + [3]                  
                 p(c_24) = [1] x1 + [3]                  
                 p(c_25) = [1] x1 + [0]                  
                 p(c_26) = [1] x1 + [1]                  
                 p(c_27) = [1] x1 + [4]                  
                 p(c_28) = [1]                           
                 p(c_29) = [1] x1 + [1]                  
                 p(c_30) = [0]                           
                 p(c_31) = [1] x1 + [0]                  
                 p(c_32) = [1] x1 + [0]                  
                 p(c_33) = [1] x1 + [4]                  
                 p(c_34) = [0]                           
                 p(c_35) = [0]                           
                 p(c_36) = [1] x1 + [0]                  
                 p(c_37) = [0]                           
                 p(c_38) = [1] x1 + [0]                  
                 p(c_39) = [0]                           
                 p(c_40) = [0]                           
                 p(c_41) = [0]                           
                 p(c_42) = [0]                           
                 p(c_43) = [0]                           
                 p(c_44) = [0]                           
                 p(c_45) = [0]                           
                 p(c_46) = [0]                           
                 p(c_47) = [0]                           
                 p(c_48) = [0]                           
                 p(c_49) = [1]                           
                 p(c_50) = [1] x1 + [0]                  
                 p(c_51) = [0]                           
                 p(c_52) = [2]                           
                 p(c_53) = [0]                           
          
          Following rules are strictly oriented:
          l15#(x,y,res,tmp,False(),t) = [1] t + [4]      
                                      > [1]              
                                      = c_26(gcd#(y,0()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                       
                                         >= [3]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [2] mtmp + [1] tmp + [1]                  
                                         >= [1] mtmp + [6]                            
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [1] res + [3] tmp + [0]                   
                                         >= [2] tmp + [7]                             
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [2] tmp + [7]                             
                                         >= [7]                                       
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [2] tmp + [7]                             
                                         >= [2] tmp + [0]                             
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [4] t + [2] tmp + [0]                     
                                         >= [4] t + [11]                              
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [4] t + [4]                               
                                         >= [3]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [4] t + [4]                               
                                         >= [3]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [1] t + [4]                               
                                         >= [1] t + [4]                               
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
              l15#(x,y,res,tmp,True(),t) =  [1] t + [4]                               
                                         >= [4]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [1] mtmp + [6]                            
                                         >= [6]                                       
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [5]                                       
                                         >= [5]                                       
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [4] res + [1]                             
                                         >= [4] res + [5]                             
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [4] res + [5]                             
                                         >= [3] res + [5]                             
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [3] res + [4] t + [1]                     
                                         >= [2] res + [1] t + [1]                     
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [2] res + [1] t + [0]                     
                                         >= [1] res + [0]                             
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [1] res + [1]                             
                                         >= [1] res + [1]                             
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [1] res + [1]                             
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [1] res + [1]                             
                                         >= [0]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [1]                                       
                                         >= [1]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [4] res + [0]                             
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [5] t + [0]                               
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:7: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                                    
                    p(<) = [0]                                    
                p(False) = [0]                                    
                    p(S) = [0]                                    
                 p(True) = [0]                                    
             p(bool2Nat) = [1] x1 + [0]                           
                   p(e1) = [3] x3 + [4]                           
                   p(e2) = [1] x4 + [4]                           
                   p(e3) = [4]                                    
                   p(e4) = [1] x4 + [4]                           
                   p(e5) = [0]                                    
                   p(e6) = [0]                                    
                   p(e7) = [0]                                    
                   p(e8) = [0]                                    
               p(equal0) = [4]                                    
                  p(gcd) = [0]                                    
                p(help1) = [1]                                    
                   p(l1) = [0]                                    
                  p(l10) = [0]                                    
                  p(l11) = [0]                                    
                  p(l12) = [0]                                    
                  p(l13) = [0]                                    
                  p(l14) = [0]                                    
                  p(l15) = [0]                                    
                  p(l16) = [0]                                    
                   p(l2) = [0]                                    
                   p(l3) = [0]                                    
                   p(l4) = [0]                                    
                   p(l5) = [0]                                    
                   p(l6) = [0]                                    
                   p(l7) = [0]                                    
                   p(l8) = [0]                                    
                   p(l9) = [0]                                    
                   p(m1) = [1]                                    
                   p(m2) = [1]                                    
                   p(m3) = [0]                                    
                   p(m4) = [1]                                    
                   p(m5) = [1] x3 + [0]                           
                p(monus) = [1]                                    
                   p(<#) = [0]                                    
            p(bool2Nat#) = [0]                                    
                  p(e1#) = [0]                                    
                  p(e2#) = [0]                                    
                  p(e3#) = [0]                                    
                  p(e4#) = [0]                                    
                  p(e5#) = [0]                                    
                  p(e6#) = [0]                                    
                  p(e7#) = [0]                                    
                  p(e8#) = [0]                                    
              p(equal0#) = [0]                                    
                 p(gcd#) = [1]                                    
               p(help1#) = [0]                                    
                  p(l1#) = [4] x4 + [0]                           
                 p(l10#) = [4] x4 + [0]                           
                 p(l11#) = [4] x4 + [1] x6 + [4]                  
                 p(l12#) = [2]                                    
                 p(l13#) = [1] x5 + [2]                           
                 p(l14#) = [4] x4 + [4]                           
                 p(l15#) = [1] x5 + [1]                           
                 p(l16#) = [2] x3 + [1] x4 + [0]                  
                  p(l2#) = [4] x4 + [3]                           
                  p(l3#) = [1] x4 + [2]                           
                  p(l4#) = [4] x3 + [2]                           
                  p(l5#) = [1] x3 + [4] x6 + [2]                  
                  p(l6#) = [1] x1 + [1] x4 + [2] x5 + [4] x6 + [4]
                  p(l7#) = [1] x3 + [1] x6 + [7]                  
                  p(l8#) = [1] x3 + [1] x4 + [3]                  
                  p(l9#) = [0]                                    
                  p(m1#) = [1] x2 + [1] x3 + [0]                  
                  p(m2#) = [1] x1 + [1] x2 + [1] x4 + [0]         
                  p(m3#) = [0]                                    
                  p(m4#) = [2] x1 + [4] x2 + [2] x3 + [1] x4 + [0]
                  p(m5#) = [2] x3 + [0]                           
               p(monus#) = [1] x2 + [1]                           
                  p(c_1) = [0]                                    
                  p(c_2) = [0]                                    
                  p(c_3) = [1] x2 + [0]                           
                  p(c_4) = [2]                                    
                  p(c_5) = [0]                                    
                  p(c_6) = [1] x2 + [4]                           
                  p(c_7) = [0]                                    
                  p(c_8) = [0]                                    
                  p(c_9) = [4]                                    
                 p(c_10) = [4]                                    
                 p(c_11) = [1]                                    
                 p(c_12) = [4]                                    
                 p(c_13) = [0]                                    
                 p(c_14) = [1] x1 + [0]                           
                 p(c_15) = [0]                                    
                 p(c_16) = [1]                                    
                 p(c_17) = [0]                                    
                 p(c_18) = [1] x1 + [0]                           
                 p(c_19) = [1] x1 + [0]                           
                 p(c_20) = [1] x1 + [0]                           
                 p(c_21) = [1] x1 + [0]                           
                 p(c_22) = [1] x1 + [1]                           
                 p(c_23) = [1] x1 + [1]                           
                 p(c_24) = [1] x1 + [1]                           
                 p(c_25) = [1] x1 + [0]                           
                 p(c_26) = [1] x1 + [0]                           
                 p(c_27) = [1] x1 + [0]                           
                 p(c_28) = [1]                                    
                 p(c_29) = [1] x1 + [0]                           
                 p(c_30) = [1]                                    
                 p(c_31) = [1] x1 + [0]                           
                 p(c_32) = [1] x1 + [4]                           
                 p(c_33) = [1] x1 + [0]                           
                 p(c_34) = [0]                                    
                 p(c_35) = [1]                                    
                 p(c_36) = [1] x1 + [0]                           
                 p(c_37) = [0]                                    
                 p(c_38) = [1] x1 + [0]                           
                 p(c_39) = [1]                                    
                 p(c_40) = [4] x1 + [1]                           
                 p(c_41) = [2] x1 + [1]                           
                 p(c_42) = [1]                                    
                 p(c_43) = [1]                                    
                 p(c_44) = [1]                                    
                 p(c_45) = [1]                                    
                 p(c_46) = [4]                                    
                 p(c_47) = [1]                                    
                 p(c_48) = [1] x1 + [1]                           
                 p(c_49) = [1]                                    
                 p(c_50) = [1] x1 + [1]                           
                 p(c_51) = [1]                                    
                 p(c_52) = [2]                                    
                 p(c_53) = [2]                                    
          
          Following rules are strictly oriented:
          gcd#(x,y) = [1]                                       
                    > [0]                                       
                    = c_14(l1#(x,y,0(),False(),False(),False()))
          
          
          Following rules are (at-least) weakly oriented:
                 l1#(x,y,res,tmp,mtmp,t) =  [4] tmp + [0]                        
                                         >= [4] tmp + [3]                        
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))  
          
                l10#(x,y,res,tmp,mtmp,t) =  [4] tmp + [0]                        
                                         >= [4] tmp + [4]                        
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))  
          
          l11#(x,y,res,tmp,mtmp,False()) =  [4] tmp + [4]                        
                                         >= [4] tmp + [4]                        
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False())) 
          
           l11#(x,y,res,tmp,mtmp,True()) =  [4] tmp + [4]                        
                                         >= [2]                                  
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))  
          
                l12#(x,y,res,tmp,mtmp,t) =  [2]                                  
                                         >= [4]                                  
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t)) 
          
             l13#(x,y,res,tmp,False(),t) =  [2]                                  
                                         >= [2]                                  
                                         =  c_23(gcd#(0(),y))                    
          
              l13#(x,y,res,tmp,True(),t) =  [2]                                  
                                         >= [2]                                  
                                         =  c_24(gcd#(S(0()),y))                 
          
                l14#(x,y,res,tmp,mtmp,t) =  [4] tmp + [4]                        
                                         >= [2]                                  
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t)) 
          
             l15#(x,y,res,tmp,False(),t) =  [1]                                  
                                         >= [1]                                  
                                         =  c_26(gcd#(y,0()))                    
          
              l15#(x,y,res,tmp,True(),t) =  [1]                                  
                                         >= [1]                                  
                                         =  c_27(gcd#(y,S(0())))                 
          
           l2#(x,y,res,tmp,mtmp,False()) =  [4] tmp + [3]                        
                                         >= [1] tmp + [2]                        
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))  
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1] tmp + [2]                        
                                         >= [2]                                  
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))        
          
                l4#(x',x,res,tmp,mtmp,t) =  [4] res + [2]                        
                                         >= [1] res + [6]                        
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False())) 
          
           l5#(x,y,res,tmp,mtmp,False()) =  [1] res + [2]                        
                                         >= [1] res + [7]                        
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))  
          
                 l7#(x,y,res,tmp,mtmp,t) =  [1] res + [1] t + [7]                
                                         >= [1] res + [7]                        
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
          
             l8#(x,y,res,False(),mtmp,t) =  [1] res + [3]                        
                                         >= [0]                                  
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))   
          
                                <(x,0()) =  [0]                                  
                                         >= [0]                                  
                                         =  False()                              
          
                             <(0(),S(y)) =  [0]                                  
                                         >= [0]                                  
                                         =  True()                               
          
                            <(S(x),S(y)) =  [0]                                  
                                         >= [0]                                  
                                         =  <(x,y)                               
          
                           e1(a,b,res,t) =  [3] res + [4]                        
                                         >= [4]                                  
                                         =  e2(a,b,res,<(a,b))                   
          
                     e2(a,b,res,False()) =  [4]                                  
                                         >= [0]                                  
                                         =  False()                              
          
                      e2(a,b,res,True()) =  [4]                                  
                                         >= [4]                                  
                                         =  e3(a,b,res,True())                   
          
                           e3(a,b,res,t) =  [4]                                  
                                         >= [4]                                  
                                         =  e4(a,b,res,<(b,a))                   
          
                     e4(a,b,res,False()) =  [4]                                  
                                         >= [0]                                  
                                         =  False()                              
          
                      e4(a,b,res,True()) =  [4]                                  
                                         >= [0]                                  
                                         =  True()                               
          
                             equal0(a,b) =  [4]                                  
                                         >= [4]                                  
                                         =  e1(a,b,False(),False())              
          
                           m1(a,x,res,t) =  [1]                                  
                                         >= [1]                                  
                                         =  m2(a,x,res,False())                  
          
                     m2(a,b,res,False()) =  [1]                                  
                                         >= [1]                                  
                                         =  m4(a,b,res,False())                  
          
                    m4(S(x'),S(x),res,t) =  [1]                                  
                                         >= [1]                                  
                                         =  m5(S(x'),S(x),monus(x',x),t)         
          
                           m5(a,b,res,t) =  [1] res + [0]                        
                                         >= [1] res + [0]                        
                                         =  res                                  
          
                              monus(a,b) =  [1]                                  
                                         >= [1]                                  
                                         =  m1(a,b,False(),False())              
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:8: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                  
                    p(<) = [1]                  
                p(False) = [0]                  
                    p(S) = [0]                  
                 p(True) = [1]                  
             p(bool2Nat) = [1]                  
                   p(e1) = [5]                  
                   p(e2) = [1] x4 + [4]         
                   p(e3) = [2] x4 + [1]         
                   p(e4) = [1] x4 + [0]         
                   p(e5) = [0]                  
                   p(e6) = [0]                  
                   p(e7) = [0]                  
                   p(e8) = [0]                  
               p(equal0) = [5]                  
                  p(gcd) = [0]                  
                p(help1) = [0]                  
                   p(l1) = [0]                  
                  p(l10) = [0]                  
                  p(l11) = [0]                  
                  p(l12) = [0]                  
                  p(l13) = [0]                  
                  p(l14) = [0]                  
                  p(l15) = [1] x3 + [0]         
                  p(l16) = [0]                  
                   p(l2) = [0]                  
                   p(l3) = [0]                  
                   p(l4) = [0]                  
                   p(l5) = [0]                  
                   p(l6) = [0]                  
                   p(l7) = [0]                  
                   p(l8) = [0]                  
                   p(l9) = [0]                  
                   p(m1) = [0]                  
                   p(m2) = [0]                  
                   p(m3) = [0]                  
                   p(m4) = [0]                  
                   p(m5) = [1] x3 + [0]         
                p(monus) = [0]                  
                   p(<#) = [0]                  
            p(bool2Nat#) = [0]                  
                  p(e1#) = [0]                  
                  p(e2#) = [0]                  
                  p(e3#) = [0]                  
                  p(e4#) = [0]                  
                  p(e5#) = [0]                  
                  p(e6#) = [0]                  
                  p(e7#) = [0]                  
                  p(e8#) = [0]                  
              p(equal0#) = [0]                  
                 p(gcd#) = [0]                  
               p(help1#) = [0]                  
                  p(l1#) = [1] x5 + [0]         
                 p(l10#) = [0]                  
                 p(l11#) = [1] x6 + [1]         
                 p(l12#) = [2]                  
                 p(l13#) = [1] x5 + [0]         
                 p(l14#) = [1]                  
                 p(l15#) = [1] x5 + [1]         
                 p(l16#) = [0]                  
                  p(l2#) = [1]                  
                  p(l3#) = [1]                  
                  p(l4#) = [1]                  
                  p(l5#) = [1]                  
                  p(l6#) = [0]                  
                  p(l7#) = [5] x6 + [7]         
                  p(l8#) = [1] x4 + [4] x6 + [2]
                  p(l9#) = [0]                  
                  p(m1#) = [0]                  
                  p(m2#) = [0]                  
                  p(m3#) = [0]                  
                  p(m4#) = [0]                  
                  p(m5#) = [0]                  
               p(monus#) = [0]                  
                  p(c_1) = [0]                  
                  p(c_2) = [0]                  
                  p(c_3) = [0]                  
                  p(c_4) = [0]                  
                  p(c_5) = [0]                  
                  p(c_6) = [0]                  
                  p(c_7) = [0]                  
                  p(c_8) = [0]                  
                  p(c_9) = [0]                  
                 p(c_10) = [0]                  
                 p(c_11) = [0]                  
                 p(c_12) = [0]                  
                 p(c_13) = [2]                  
                 p(c_14) = [1] x1 + [0]         
                 p(c_15) = [0]                  
                 p(c_16) = [0]                  
                 p(c_17) = [0]                  
                 p(c_18) = [1] x1 + [0]         
                 p(c_19) = [1] x1 + [0]         
                 p(c_20) = [1] x1 + [0]         
                 p(c_21) = [1] x1 + [0]         
                 p(c_22) = [1] x1 + [0]         
                 p(c_23) = [1] x1 + [0]         
                 p(c_24) = [1] x1 + [0]         
                 p(c_25) = [1] x1 + [0]         
                 p(c_26) = [1] x1 + [0]         
                 p(c_27) = [1] x1 + [0]         
                 p(c_28) = [0]                  
                 p(c_29) = [1] x1 + [0]         
                 p(c_30) = [0]                  
                 p(c_31) = [1] x1 + [0]         
                 p(c_32) = [1] x1 + [0]         
                 p(c_33) = [1] x1 + [3]         
                 p(c_34) = [0]                  
                 p(c_35) = [0]                  
                 p(c_36) = [1] x1 + [0]         
                 p(c_37) = [0]                  
                 p(c_38) = [1] x1 + [2]         
                 p(c_39) = [2]                  
                 p(c_40) = [2] x1 + [0]         
                 p(c_41) = [4]                  
                 p(c_42) = [1]                  
                 p(c_43) = [0]                  
                 p(c_44) = [0]                  
                 p(c_45) = [2]                  
                 p(c_46) = [0]                  
                 p(c_47) = [1]                  
                 p(c_48) = [1]                  
                 p(c_49) = [1]                  
                 p(c_50) = [1] x1 + [0]         
                 p(c_51) = [0]                  
                 p(c_52) = [0]                  
                 p(c_53) = [1] x1 + [0]         
          
          Following rules are strictly oriented:
          l12#(x,y,res,tmp,mtmp,t) = [2]                                 
                                   > [0]                                 
                                   = c_22(l13#(x,y,res,tmp,monus(x,y),t))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                       
                                         >= [0]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [1] mtmp + [0]                            
                                         >= [1]                                       
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [0]                                       
                                         >= [2]                                       
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [1]                                       
                                         >= [1]                                       
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [2]                                       
                                         >= [2]                                       
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
             l13#(x,y,res,tmp,False(),t) =  [0]                                       
                                         >= [0]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [1]                                       
                                         >= [0]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [1]                                       
                                         >= [1]                                       
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [1]                                       
                                         >= [0]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [2]                                       
                                         >= [0]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [1]                                       
                                         >= [1]                                       
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1]                                       
                                         >= [1]                                       
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [1]                                       
                                         >= [1]                                       
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [1]                                       
                                         >= [10]                                      
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [5] t + [7]                               
                                         >= [4] t + [7]                               
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [4] t + [2]                               
                                         >= [2]                                       
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [1]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [1]                                       
                                         >= [1]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [1]                                       
                                         >= [1]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [5]                                       
                                         >= [5]                                       
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [4]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [5]                                       
                                         >= [3]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [2] t + [1]                               
                                         >= [1]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [1]                                       
                                         >= [1]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [5]                                       
                                         >= [5]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:9: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                                    
                    p(<) = [0]                                    
                p(False) = [0]                                    
                    p(S) = [0]                                    
                 p(True) = [0]                                    
             p(bool2Nat) = [1] x1 + [0]                           
                   p(e1) = [4] x4 + [0]                           
                   p(e2) = [1] x4 + [0]                           
                   p(e3) = [0]                                    
                   p(e4) = [1] x4 + [0]                           
                   p(e5) = [0]                                    
                   p(e6) = [0]                                    
                   p(e7) = [0]                                    
                   p(e8) = [2] x4 + [0]                           
               p(equal0) = [0]                                    
                  p(gcd) = [0]                                    
                p(help1) = [0]                                    
                   p(l1) = [0]                                    
                  p(l10) = [0]                                    
                  p(l11) = [0]                                    
                  p(l12) = [0]                                    
                  p(l13) = [0]                                    
                  p(l14) = [0]                                    
                  p(l15) = [0]                                    
                  p(l16) = [0]                                    
                   p(l2) = [1] x1 + [0]                           
                   p(l3) = [0]                                    
                   p(l4) = [0]                                    
                   p(l5) = [0]                                    
                   p(l6) = [0]                                    
                   p(l7) = [0]                                    
                   p(l8) = [0]                                    
                   p(l9) = [0]                                    
                   p(m1) = [2] x3 + [0]                           
                   p(m2) = [2] x3 + [0]                           
                   p(m3) = [2] x1 + [1] x3 + [4]                  
                   p(m4) = [1] x3 + [2] x4 + [0]                  
                   p(m5) = [4] x2 + [1] x3 + [0]                  
                p(monus) = [0]                                    
                   p(<#) = [2]                                    
            p(bool2Nat#) = [1]                                    
                  p(e1#) = [4] x3 + [2] x4 + [0]                  
                  p(e2#) = [2] x1 + [1] x2 + [1] x3 + [0]         
                  p(e3#) = [1] x1 + [1] x3 + [1] x4 + [0]         
                  p(e4#) = [4] x1 + [1] x2 + [2] x3 + [4] x4 + [2]
                  p(e5#) = [4] x1 + [4] x2 + [1] x3 + [1] x4 + [0]
                  p(e6#) = [1] x1 + [1] x3 + [1] x4 + [0]         
                  p(e7#) = [1] x1 + [1] x2 + [1] x4 + [0]         
                  p(e8#) = [4] x3 + [4] x4 + [1]                  
              p(equal0#) = [1] x2 + [1]                           
                 p(gcd#) = [4]                                    
               p(help1#) = [2] x1 + [0]                           
                  p(l1#) = [4] x3 + [7] x4 + [6] x5 + [0]         
                 p(l10#) = [2] x3 + [1] x4 + [1] x5 + [1] x6 + [0]
                 p(l11#) = [1] x3 + [1] x5 + [1] x6 + [7]         
                 p(l12#) = [1] x3 + [5]                           
                 p(l13#) = [1] x5 + [4]                           
                 p(l14#) = [1] x3 + [1] x5 + [1] x6 + [6]         
                 p(l15#) = [1] x5 + [1] x6 + [6]                  
                 p(l16#) = [1] x1 + [2] x2 + [1] x3 + [1] x4 + [0]
                  p(l2#) = [5] x4 + [6] x5 + [1] x6 + [3]         
                  p(l3#) = [4] x4 + [6] x5 + [2]                  
                  p(l4#) = [7] x3 + [3] x4 + [5] x5 + [1]         
                  p(l5#) = [5] x3 + [2] x4 + [4] x5 + [1] x6 + [0]
                  p(l6#) = [1] x1 + [4] x2 + [0]                  
                  p(l7#) = [4] x3 + [2] x4 + [4] x5 + [5] x6 + [1]
                  p(l8#) = [2] x3 + [1] x4 + [4] x5 + [1] x6 + [1]
                  p(l9#) = [4] x2 + [1] x3 + [1] x4 + [0]         
                  p(m1#) = [1] x2 + [1] x3 + [2] x4 + [4]         
                  p(m2#) = [2] x1 + [1] x2 + [4] x3 + [2] x4 + [1]
                  p(m3#) = [1] x1 + [2] x2 + [1] x3 + [1] x4 + [0]
                  p(m4#) = [4] x1 + [1] x2 + [4] x4 + [2]         
                  p(m5#) = [0]                                    
               p(monus#) = [4] x2 + [0]                           
                  p(c_1) = [4]                                    
                  p(c_2) = [0]                                    
                  p(c_3) = [1] x1 + [2] x2 + [0]                  
                  p(c_4) = [2]                                    
                  p(c_5) = [2] x1 + [2]                           
                  p(c_6) = [4] x1 + [2] x2 + [1]                  
                  p(c_7) = [0]                                    
                  p(c_8) = [1]                                    
                  p(c_9) = [0]                                    
                 p(c_10) = [4]                                    
                 p(c_11) = [2]                                    
                 p(c_12) = [1]                                    
                 p(c_13) = [1]                                    
                 p(c_14) = [1] x1 + [1]                           
                 p(c_15) = [4]                                    
                 p(c_16) = [0]                                    
                 p(c_17) = [0]                                    
                 p(c_18) = [1] x1 + [1]                           
                 p(c_19) = [1] x1 + [4]                           
                 p(c_20) = [1] x1 + [1]                           
                 p(c_21) = [1] x1 + [0]                           
                 p(c_22) = [1] x1 + [1]                           
                 p(c_23) = [1] x1 + [0]                           
                 p(c_24) = [1] x1 + [0]                           
                 p(c_25) = [1] x1 + [0]                           
                 p(c_26) = [1] x1 + [2]                           
                 p(c_27) = [1] x1 + [2]                           
                 p(c_28) = [0]                                    
                 p(c_29) = [1] x1 + [1]                           
                 p(c_30) = [1]                                    
                 p(c_31) = [1] x1 + [1]                           
                 p(c_32) = [1] x1 + [0]                           
                 p(c_33) = [1] x1 + [0]                           
                 p(c_34) = [1]                                    
                 p(c_35) = [1]                                    
                 p(c_36) = [1] x1 + [0]                           
                 p(c_37) = [1]                                    
                 p(c_38) = [1] x1 + [1]                           
                 p(c_39) = [1]                                    
                 p(c_40) = [0]                                    
                 p(c_41) = [1]                                    
                 p(c_42) = [0]                                    
                 p(c_43) = [0]                                    
                 p(c_44) = [1]                                    
                 p(c_45) = [0]                                    
                 p(c_46) = [1]                                    
                 p(c_47) = [1]                                    
                 p(c_48) = [1] x1 + [1]                           
                 p(c_49) = [0]                                    
                 p(c_50) = [1] x1 + [1]                           
                 p(c_51) = [2]                                    
                 p(c_52) = [1]                                    
                 p(c_53) = [2]                                    
          
          Following rules are strictly oriented:
          l4#(x',x,res,tmp,mtmp,t) = [5] mtmp + [7] res + [3] tmp + [1]  
                                   > [4] mtmp + [5] res + [2] tmp + [0]  
                                   = c_32(l5#(x',x,res,tmp,mtmp,False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [4]                                       
                                         >= [1]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [6] mtmp + [4] res + [7] tmp + [0]        
                                         >= [6] mtmp + [5] tmp + [4]                  
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [1] mtmp + [2] res + [1] t + [1] tmp + [0]
                                         >= [1] mtmp + [1] res + [11]                 
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [1] mtmp + [1] res + [7]                  
                                         >= [1] mtmp + [1] res + [7]                  
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [1] mtmp + [1] res + [7]                  
                                         >= [1] res + [5]                             
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [1] res + [5]                             
                                         >= [5]                                       
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [4]                                       
                                         >= [4]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [4]                                       
                                         >= [4]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [1] mtmp + [1] res + [1] t + [6]          
                                         >= [1] t + [6]                               
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [1] t + [6]                               
                                         >= [6]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [1] t + [6]                               
                                         >= [6]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [6] mtmp + [5] tmp + [3]                  
                                         >= [6] mtmp + [4] tmp + [3]                  
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [6] mtmp + [4] tmp + [2]                  
                                         >= [5] mtmp + [3] tmp + [2]                  
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
           l5#(x,y,res,tmp,mtmp,False()) =  [4] mtmp + [5] res + [2] tmp + [0]        
                                         >= [4] mtmp + [4] res + [2] tmp + [1]        
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [4] mtmp + [4] res + [5] t + [2] tmp + [1]
                                         >= [4] mtmp + [2] res + [1] t + [1]          
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [4] mtmp + [2] res + [1] t + [1]          
                                         >= [1] mtmp + [2] res + [1] t + [1]          
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [4] t + [0]                               
                                         >= [0]                                       
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [2] res + [0]                             
                                         >= [2] res + [0]                             
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [2] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [1] res + [2] t + [0]                     
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [4] b + [1] res + [0]                     
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:10: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [2]                                    
                    p(<) = [0]                                    
                p(False) = [0]                                    
                    p(S) = [1] x1 + [1]                           
                 p(True) = [0]                                    
             p(bool2Nat) = [2]                                    
                   p(e1) = [5] x3 + [0]                           
                   p(e2) = [3] x3 + [1] x4 + [0]                  
                   p(e3) = [0]                                    
                   p(e4) = [1] x4 + [0]                           
                   p(e5) = [0]                                    
                   p(e6) = [2] x4 + [0]                           
                   p(e7) = [0]                                    
                   p(e8) = [0]                                    
               p(equal0) = [0]                                    
                  p(gcd) = [0]                                    
                p(help1) = [0]                                    
                   p(l1) = [0]                                    
                  p(l10) = [0]                                    
                  p(l11) = [0]                                    
                  p(l12) = [0]                                    
                  p(l13) = [0]                                    
                  p(l14) = [1] x1 + [2] x5 + [0]                  
                  p(l15) = [0]                                    
                  p(l16) = [0]                                    
                   p(l2) = [0]                                    
                   p(l3) = [0]                                    
                   p(l4) = [0]                                    
                   p(l5) = [0]                                    
                   p(l6) = [0]                                    
                   p(l7) = [0]                                    
                   p(l8) = [0]                                    
                   p(l9) = [0]                                    
                   p(m1) = [0]                                    
                   p(m2) = [0]                                    
                   p(m3) = [0]                                    
                   p(m4) = [0]                                    
                   p(m5) = [1] x3 + [0]                           
                p(monus) = [0]                                    
                   p(<#) = [0]                                    
            p(bool2Nat#) = [0]                                    
                  p(e1#) = [0]                                    
                  p(e2#) = [0]                                    
                  p(e3#) = [0]                                    
                  p(e4#) = [0]                                    
                  p(e5#) = [0]                                    
                  p(e6#) = [0]                                    
                  p(e7#) = [2] x2 + [0]                           
                  p(e8#) = [2] x1 + [1] x3 + [1]                  
              p(equal0#) = [1] x2 + [2]                           
                 p(gcd#) = [0]                                    
               p(help1#) = [4] x1 + [1]                           
                  p(l1#) = [1] x4 + [6] x5 + [0]                  
                 p(l10#) = [2] x3 + [4] x4 + [0]                  
                 p(l11#) = [2] x3 + [4] x4 + [1] x6 + [7]         
                 p(l12#) = [2] x3 + [7]                           
                 p(l13#) = [1] x5 + [7]                           
                 p(l14#) = [2] x3 + [7]                           
                 p(l15#) = [1] x3 + [1] x5 + [5]                  
                 p(l16#) = [1] x6 + [0]                           
                  p(l2#) = [1] x4 + [4] x5 + [5]                  
                  p(l3#) = [1] x4 + [4] x5 + [1] x6 + [5]         
                  p(l4#) = [2] x3 + [4] x5 + [1] x6 + [1]         
                  p(l5#) = [2] x3 + [1] x5 + [1]                  
                  p(l6#) = [0]                                    
                  p(l7#) = [2] x3 + [4] x6 + [0]                  
                  p(l8#) = [2] x3 + [1] x4 + [0]                  
                  p(l9#) = [1] x3 + [4] x4 + [1] x5 + [1] x6 + [0]
                  p(m1#) = [1] x2 + [2] x3 + [0]                  
                  p(m2#) = [0]                                    
                  p(m3#) = [1] x1 + [2] x3 + [1] x4 + [1]         
                  p(m4#) = [4] x3 + [2] x4 + [1]                  
                  p(m5#) = [1] x1 + [4] x2 + [1] x3 + [1] x4 + [1]
               p(monus#) = [1] x1 + [0]                           
                  p(c_1) = [1]                                    
                  p(c_2) = [0]                                    
                  p(c_3) = [2] x1 + [1] x2 + [0]                  
                  p(c_4) = [2]                                    
                  p(c_5) = [0]                                    
                  p(c_6) = [1] x1 + [4]                           
                  p(c_7) = [1]                                    
                  p(c_8) = [1]                                    
                  p(c_9) = [0]                                    
                 p(c_10) = [4]                                    
                 p(c_11) = [1]                                    
                 p(c_12) = [4]                                    
                 p(c_13) = [1] x1 + [0]                           
                 p(c_14) = [1] x1 + [0]                           
                 p(c_15) = [4]                                    
                 p(c_16) = [0]                                    
                 p(c_17) = [2]                                    
                 p(c_18) = [1] x1 + [2]                           
                 p(c_19) = [1] x1 + [0]                           
                 p(c_20) = [1] x1 + [0]                           
                 p(c_21) = [1] x1 + [0]                           
                 p(c_22) = [1] x1 + [0]                           
                 p(c_23) = [1] x1 + [4]                           
                 p(c_24) = [1] x1 + [7]                           
                 p(c_25) = [1] x1 + [1]                           
                 p(c_26) = [1] x1 + [5]                           
                 p(c_27) = [1] x1 + [5]                           
                 p(c_28) = [1]                                    
                 p(c_29) = [1] x1 + [0]                           
                 p(c_30) = [1]                                    
                 p(c_31) = [1] x1 + [0]                           
                 p(c_32) = [1] x1 + [0]                           
                 p(c_33) = [1] x1 + [0]                           
                 p(c_34) = [0]                                    
                 p(c_35) = [2]                                    
                 p(c_36) = [1] x1 + [0]                           
                 p(c_37) = [0]                                    
                 p(c_38) = [1] x1 + [0]                           
                 p(c_39) = [1]                                    
                 p(c_40) = [1] x1 + [2]                           
                 p(c_41) = [2] x1 + [0]                           
                 p(c_42) = [0]                                    
                 p(c_43) = [0]                                    
                 p(c_44) = [1]                                    
                 p(c_45) = [4]                                    
                 p(c_46) = [4]                                    
                 p(c_47) = [1]                                    
                 p(c_48) = [1]                                    
                 p(c_49) = [0]                                    
                 p(c_50) = [1] x1 + [0]                           
                 p(c_51) = [0]                                    
                 p(c_52) = [4]                                    
                 p(c_53) = [1] x1 + [1]                           
          
          Following rules are strictly oriented:
          l5#(x,y,res,tmp,mtmp,False()) = [1] mtmp + [2] res + [1]           
                                        > [2] res + [0]                      
                                        = c_33(l7#(x,y,res,tmp,mtmp,False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                       
                                         >= [0]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [6] mtmp + [1] tmp + [0]                  
                                         >= [4] mtmp + [1] tmp + [7]                  
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
                l10#(x,y,res,tmp,mtmp,t) =  [2] res + [4] tmp + [0]                   
                                         >= [2] res + [4] tmp + [7]                   
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [2] res + [4] tmp + [7]                   
                                         >= [2] res + [7]                             
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [2] res + [4] tmp + [7]                   
                                         >= [2] res + [7]                             
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [2] res + [7]                             
                                         >= [7]                                       
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [7]                                       
                                         >= [4]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [7]                                       
                                         >= [7]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [2] res + [7]                             
                                         >= [1] res + [6]                             
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [1] res + [5]                             
                                         >= [5]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [1] res + [5]                             
                                         >= [5]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [4] mtmp + [1] tmp + [5]                  
                                         >= [4] mtmp + [1] tmp + [5]                  
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [4] mtmp + [1] t + [1] tmp + [5]          
                                         >= [4] mtmp + [1] t + [5]                    
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [4] mtmp + [2] res + [1] t + [1]          
                                         >= [1] mtmp + [2] res + [1]                  
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
                 l7#(x,y,res,tmp,mtmp,t) =  [2] res + [4] t + [0]                     
                                         >= [2] res + [0]                             
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [2] res + [0]                             
                                         >= [2] res + [0]                             
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [5] res + [0]                             
                                         >= [3] res + [0]                             
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [3] res + [0]                             
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [3] res + [0]                             
                                         >= [0]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:11: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                                                      
                    p(<) = [0]                                                      
                p(False) = [0]                                                      
                    p(S) = [1] x1 + [0]                                             
                 p(True) = [0]                                                      
             p(bool2Nat) = [1]                                                      
                   p(e1) = [0]                                                      
                   p(e2) = [1] x4 + [0]                                             
                   p(e3) = [0]                                                      
                   p(e4) = [1] x4 + [0]                                             
                   p(e5) = [0]                                                      
                   p(e6) = [0]                                                      
                   p(e7) = [0]                                                      
                   p(e8) = [0]                                                      
               p(equal0) = [0]                                                      
                  p(gcd) = [0]                                                      
                p(help1) = [0]                                                      
                   p(l1) = [0]                                                      
                  p(l10) = [0]                                                      
                  p(l11) = [0]                                                      
                  p(l12) = [0]                                                      
                  p(l13) = [0]                                                      
                  p(l14) = [0]                                                      
                  p(l15) = [0]                                                      
                  p(l16) = [0]                                                      
                   p(l2) = [0]                                                      
                   p(l3) = [0]                                                      
                   p(l4) = [1] x6 + [0]                                             
                   p(l5) = [1] x1 + [2] x3 + [4] x4 + [1]                           
                   p(l6) = [1] x1 + [1] x3 + [1] x4 + [1] x5 + [1] x6 + [1]         
                   p(l7) = [2] x1 + [4] x3 + [1] x5 + [0]                           
                   p(l8) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [2] x5 + [1] x6 + [2]
                   p(l9) = [1] x1 + [2] x2 + [2] x3 + [1] x4 + [4] x5 + [4] x6 + [1]
                   p(m1) = [4] x3 + [4] x4 + [0]                                    
                   p(m2) = [3] x3 + [1] x4 + [0]                                    
                   p(m3) = [1] x2 + [0]                                             
                   p(m4) = [1] x3 + [1] x4 + [0]                                    
                   p(m5) = [1] x3 + [1] x4 + [0]                                    
                p(monus) = [0]                                                      
                   p(<#) = [2] x1 + [1] x2 + [4]                                    
            p(bool2Nat#) = [1] x1 + [1]                                             
                  p(e1#) = [4] x1 + [1] x2 + [2]                                    
                  p(e2#) = [2] x3 + [0]                                             
                  p(e3#) = [1] x1 + [2] x2 + [1] x4 + [2]                           
                  p(e4#) = [1] x1 + [1] x2 + [1] x3 + [0]                           
                  p(e5#) = [2] x1 + [2] x3 + [1] x4 + [2]                           
                  p(e6#) = [1] x3 + [1] x4 + [0]                                    
                  p(e7#) = [1] x1 + [1] x2 + [2] x4 + [1]                           
                  p(e8#) = [1] x3 + [1] x4 + [4]                                    
              p(equal0#) = [1] x2 + [1]                                             
                 p(gcd#) = [0]                                                      
               p(help1#) = [4] x1 + [1]                                             
                  p(l1#) = [5] x3 + [5] x4 + [2] x5 + [0]                           
                 p(l10#) = [6] x4 + [2] x6 + [7]                                    
                 p(l11#) = [6] x4 + [1] x6 + [6]                                    
                 p(l12#) = [3]                                                      
                 p(l13#) = [1] x5 + [2]                                             
                 p(l14#) = [4] x4 + [6]                                             
                 p(l15#) = [1] x5 + [6]                                             
                 p(l16#) = [2] x1 + [1] x2 + [4] x5 + [1] x6 + [1]                  
                  p(l2#) = [1] x3 + [5] x4 + [1] x5 + [7]                           
                  p(l3#) = [1] x3 + [5] x4 + [1] x5 + [7]                           
                  p(l4#) = [5] x4 + [1] x5 + [7]                                    
                  p(l5#) = [4] x4 + [1] x5 + [7]                                    
                  p(l6#) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [2] x5 + [4] x6 + [2]
                  p(l7#) = [1] x4 + [1] x5 + [4] x6 + [7]                           
                  p(l8#) = [1] x4 + [4] x6 + [7]                                    
                  p(l9#) = [4] x3 + [1] x4 + [2] x6 + [1]                           
                  p(m1#) = [2] x2 + [1] x3 + [0]                                    
                  p(m2#) = [2] x4 + [0]                                             
                  p(m3#) = [2] x1 + [4] x3 + [1] x4 + [1]                           
                  p(m4#) = [1] x1 + [1] x2 + [2] x4 + [0]                           
                  p(m5#) = [1] x3 + [2] x4 + [1]                                    
               p(monus#) = [2] x2 + [0]                                             
                  p(c_1) = [0]                                                      
                  p(c_2) = [0]                                                      
                  p(c_3) = [1] x1 + [2] x2 + [1]                                    
                  p(c_4) = [1]                                                      
                  p(c_5) = [1]                                                      
                  p(c_6) = [1]                                                      
                  p(c_7) = [0]                                                      
                  p(c_8) = [1]                                                      
                  p(c_9) = [1]                                                      
                 p(c_10) = [0]                                                      
                 p(c_11) = [1]                                                      
                 p(c_12) = [2]                                                      
                 p(c_13) = [1]                                                      
                 p(c_14) = [1] x1 + [0]                                             
                 p(c_15) = [4]                                                      
                 p(c_16) = [0]                                                      
                 p(c_17) = [4]                                                      
                 p(c_18) = [1] x1 + [1]                                             
                 p(c_19) = [1] x1 + [0]                                             
                 p(c_20) = [1] x1 + [0]                                             
                 p(c_21) = [1] x1 + [0]                                             
                 p(c_22) = [1] x1 + [0]                                             
                 p(c_23) = [1] x1 + [1]                                             
                 p(c_24) = [1] x1 + [2]                                             
                 p(c_25) = [1] x1 + [0]                                             
                 p(c_26) = [1] x1 + [6]                                             
                 p(c_27) = [1] x1 + [6]                                             
                 p(c_28) = [0]                                                      
                 p(c_29) = [1] x1 + [0]                                             
                 p(c_30) = [4]                                                      
                 p(c_31) = [1] x1 + [0]                                             
                 p(c_32) = [1] x1 + [0]                                             
                 p(c_33) = [1] x1 + [0]                                             
                 p(c_34) = [1]                                                      
                 p(c_35) = [1]                                                      
                 p(c_36) = [1] x1 + [0]                                             
                 p(c_37) = [4]                                                      
                 p(c_38) = [1] x1 + [0]                                             
                 p(c_39) = [0]                                                      
                 p(c_40) = [2] x1 + [0]                                             
                 p(c_41) = [4] x1 + [1]                                             
                 p(c_42) = [0]                                                      
                 p(c_43) = [0]                                                      
                 p(c_44) = [0]                                                      
                 p(c_45) = [1]                                                      
                 p(c_46) = [4]                                                      
                 p(c_47) = [0]                                                      
                 p(c_48) = [1]                                                      
                 p(c_49) = [0]                                                      
                 p(c_50) = [4] x1 + [0]                                             
                 p(c_51) = [1]                                                      
                 p(c_52) = [0]                                                      
                 p(c_53) = [1] x1 + [1]                                             
          
          Following rules are strictly oriented:
          l10#(x,y,res,tmp,mtmp,t) = [2] t + [6] tmp + [7]              
                                   > [6] tmp + [6]                      
                                   = c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                       
                                         >= [0]                                       
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                 l1#(x,y,res,tmp,mtmp,t) =  [2] mtmp + [5] res + [5] tmp + [0]        
                                         >= [1] mtmp + [1] res + [5] tmp + [8]        
                                         =  c_18(l2#(x,y,res,tmp,mtmp,False()))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [6] tmp + [6]                             
                                         >= [4] tmp + [6]                             
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [6] tmp + [6]                             
                                         >= [3]                                       
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [3]                                       
                                         >= [2]                                       
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [2]                                       
                                         >= [1]                                       
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [2]                                       
                                         >= [2]                                       
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [4] tmp + [6]                             
                                         >= [6]                                       
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [6]                                       
                                         >= [6]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [6]                                       
                                         >= [6]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [1] mtmp + [1] res + [5] tmp + [7]        
                                         >= [1] mtmp + [1] res + [5] tmp + [7]        
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1] mtmp + [1] res + [5] tmp + [7]        
                                         >= [1] mtmp + [5] tmp + [7]                  
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [1] mtmp + [5] tmp + [7]                  
                                         >= [1] mtmp + [4] tmp + [7]                  
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [1] mtmp + [4] tmp + [7]                  
                                         >= [1] mtmp + [1] tmp + [7]                  
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [1] mtmp + [4] t + [1] tmp + [7]          
                                         >= [4] t + [7]                               
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [4] t + [7]                               
                                         >= [2] t + [7]                               
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [0]                                       
                                         >= [0]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [0]                                       
                                         >= [0]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [4] res + [4] t + [0]                     
                                         >= [3] res + [0]                             
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [3] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [1] res + [1] t + [0]                     
                                         >= [1] t + [0]                               
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [1] t + [0]                     
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:12: WeightGap WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict DPs:
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_14) = {1},
            uargs(c_18) = {1},
            uargs(c_19) = {1},
            uargs(c_20) = {1},
            uargs(c_21) = {1},
            uargs(c_22) = {1},
            uargs(c_23) = {1},
            uargs(c_24) = {1},
            uargs(c_25) = {1},
            uargs(c_26) = {1},
            uargs(c_27) = {1},
            uargs(c_29) = {1},
            uargs(c_31) = {1},
            uargs(c_32) = {1},
            uargs(c_33) = {1},
            uargs(c_36) = {1},
            uargs(c_38) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [3]                                             
                    p(<) = [4]                                             
                p(False) = [4]                                             
                    p(S) = [0]                                             
                 p(True) = [4]                                             
             p(bool2Nat) = [1] x1 + [1]                                    
                   p(e1) = [4]                                             
                   p(e2) = [1] x4 + [0]                                    
                   p(e3) = [4]                                             
                   p(e4) = [1] x4 + [0]                                    
                   p(e5) = [4] x1 + [1] x3 + [1]                           
                   p(e6) = [1] x1 + [1] x2 + [1] x3 + [1]                  
                   p(e7) = [1] x1 + [2]                                    
                   p(e8) = [0]                                             
               p(equal0) = [4]                                             
                  p(gcd) = [0]                                             
                p(help1) = [0]                                             
                   p(l1) = [0]                                             
                  p(l10) = [0]                                             
                  p(l11) = [0]                                             
                  p(l12) = [0]                                             
                  p(l13) = [0]                                             
                  p(l14) = [0]                                             
                  p(l15) = [0]                                             
                  p(l16) = [0]                                             
                   p(l2) = [0]                                             
                   p(l3) = [0]                                             
                   p(l4) = [0]                                             
                   p(l5) = [4] x4 + [1] x6 + [0]                           
                   p(l6) = [1] x1 + [1] x3 + [2] x5 + [1]                  
                   p(l7) = [4] x1 + [1] x2 + [1] x3 + [1] x5 + [2] x6 + [1]
                   p(l8) = [1] x1 + [1] x3 + [4] x4 + [4]                  
                   p(l9) = [1] x1 + [4] x4 + [4] x5 + [1]                  
                   p(m1) = [0]                                             
                   p(m2) = [0]                                             
                   p(m3) = [1] x1 + [1] x3 + [2]                           
                   p(m4) = [0]                                             
                   p(m5) = [1] x3 + [0]                                    
                p(monus) = [0]                                             
                   p(<#) = [2] x2 + [0]                                    
            p(bool2Nat#) = [0]                                             
                  p(e1#) = [1] x1 + [1] x3 + [1] x4 + [0]                  
                  p(e2#) = [1] x1 + [1] x3 + [2]                           
                  p(e3#) = [4] x1 + [1] x4 + [1]                           
                  p(e4#) = [2] x1 + [1] x2 + [1] x4 + [1]                  
                  p(e5#) = [4] x2 + [2] x4 + [2]                           
                  p(e6#) = [4] x1 + [1] x2 + [1] x3 + [0]                  
                  p(e7#) = [1] x3 + [1]                                    
                  p(e8#) = [4] x2 + [0]                                    
              p(equal0#) = [1] x2 + [4]                                    
                 p(gcd#) = [1] x2 + [5]                                    
               p(help1#) = [2] x1 + [0]                                    
                  p(l1#) = [1] x2 + [5]                                    
                 p(l10#) = [1] x2 + [4]                                    
                 p(l11#) = [1] x2 + [1] x6 + [0]                           
                 p(l12#) = [1] x2 + [2]                                    
                 p(l13#) = [1] x2 + [1] x5 + [1]                           
                 p(l14#) = [4]                                             
                 p(l15#) = [1] x5 + [4]                                    
                 p(l16#) = [2] x1 + [4] x2 + [1] x3 + [2] x4 + [2] x6 + [0]
                  p(l2#) = [1] x2 + [1] x6 + [0]                           
                  p(l3#) = [1] x2 + [4]                                    
                  p(l4#) = [1] x2 + [4]                                    
                  p(l5#) = [1] x2 + [1] x6 + [0]                           
                  p(l6#) = [1] x1 + [1] x3 + [4] x6 + [0]                  
                  p(l7#) = [1] x2 + [4]                                    
                  p(l8#) = [1] x2 + [1] x4 + [0]                           
                  p(l9#) = [1] x1 + [1] x2 + [1] x3 + [4] x4 + [2] x5 + [4]
                  p(m1#) = [1] x4 + [1]                                    
                  p(m2#) = [1] x1 + [1] x3 + [1] x4 + [1]                  
                  p(m3#) = [4] x3 + [0]                                    
                  p(m4#) = [1] x1 + [1] x2 + [1] x4 + [0]                  
                  p(m5#) = [2] x1 + [0]                                    
               p(monus#) = [2]                                             
                  p(c_1) = [1]                                             
                  p(c_2) = [4]                                             
                  p(c_3) = [1] x1 + [2] x2 + [0]                           
                  p(c_4) = [0]                                             
                  p(c_5) = [1] x1 + [1]                                    
                  p(c_6) = [1] x2 + [0]                                    
                  p(c_7) = [4]                                             
                  p(c_8) = [1]                                             
                  p(c_9) = [1]                                             
                 p(c_10) = [0]                                             
                 p(c_11) = [0]                                             
                 p(c_12) = [1]                                             
                 p(c_13) = [1]                                             
                 p(c_14) = [1] x1 + [0]                                    
                 p(c_15) = [4]                                             
                 p(c_16) = [2]                                             
                 p(c_17) = [1]                                             
                 p(c_18) = [1] x1 + [0]                                    
                 p(c_19) = [1] x1 + [0]                                    
                 p(c_20) = [1] x1 + [0]                                    
                 p(c_21) = [1] x1 + [2]                                    
                 p(c_22) = [1] x1 + [0]                                    
                 p(c_23) = [1] x1 + [0]                                    
                 p(c_24) = [1] x1 + [0]                                    
                 p(c_25) = [1] x1 + [0]                                    
                 p(c_26) = [1] x1 + [0]                                    
                 p(c_27) = [1] x1 + [3]                                    
                 p(c_28) = [1]                                             
                 p(c_29) = [1] x1 + [0]                                    
                 p(c_30) = [4]                                             
                 p(c_31) = [1] x1 + [0]                                    
                 p(c_32) = [1] x1 + [0]                                    
                 p(c_33) = [1] x1 + [0]                                    
                 p(c_34) = [0]                                             
                 p(c_35) = [1]                                             
                 p(c_36) = [1] x1 + [0]                                    
                 p(c_37) = [0]                                             
                 p(c_38) = [1] x1 + [0]                                    
                 p(c_39) = [2]                                             
                 p(c_40) = [4] x1 + [0]                                    
                 p(c_41) = [1] x1 + [4]                                    
                 p(c_42) = [1]                                             
                 p(c_43) = [1]                                             
                 p(c_44) = [2]                                             
                 p(c_45) = [1]                                             
                 p(c_46) = [0]                                             
                 p(c_47) = [0]                                             
                 p(c_48) = [1]                                             
                 p(c_49) = [1]                                             
                 p(c_50) = [4] x1 + [4]                                    
                 p(c_51) = [1]                                             
                 p(c_52) = [2]                                             
                 p(c_53) = [1] x1 + [2]                                    
          
          Following rules are strictly oriented:
          l1#(x,y,res,tmp,mtmp,t) = [1] y + [5]                        
                                  > [1] y + [4]                        
                                  = c_18(l2#(x,y,res,tmp,mtmp,False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [1] y + [5]                               
                                         >= [1] y + [5]                               
                                         =  c_14(l1#(x,y,0(),False(),False(),False()))
          
                l10#(x,y,res,tmp,mtmp,t) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [1] y + [4]                               
                                         >= [4]                                       
                                         =  c_20(l14#(x,y,res,tmp,mtmp,False()))      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_21(l12#(x,y,res,tmp,mtmp,True()))       
          
                l12#(x,y,res,tmp,mtmp,t) =  [1] y + [2]                               
                                         >= [1] y + [1]                               
                                         =  c_22(l13#(x,y,res,tmp,monus(x,y),t))      
          
             l13#(x,y,res,tmp,False(),t) =  [1] y + [5]                               
                                         >= [1] y + [5]                               
                                         =  c_23(gcd#(0(),y))                         
          
              l13#(x,y,res,tmp,True(),t) =  [1] y + [5]                               
                                         >= [1] y + [5]                               
                                         =  c_24(gcd#(S(0()),y))                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [4]                                       
                                         >= [4]                                       
                                         =  c_25(l15#(x,y,res,tmp,monus(x,y),t))      
          
             l15#(x,y,res,tmp,False(),t) =  [8]                                       
                                         >= [8]                                       
                                         =  c_26(gcd#(y,0()))                         
          
              l15#(x,y,res,tmp,True(),t) =  [8]                                       
                                         >= [8]                                       
                                         =  c_27(gcd#(y,S(0())))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_29(l3#(x,y,res,tmp,mtmp,False()))       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_31(l4#(x,y,0(),tmp,mtmp,t))             
          
                l4#(x',x,res,tmp,mtmp,t) =  [1] x + [4]                               
                                         >= [1] x + [4]                               
                                         =  c_32(l5#(x',x,res,tmp,mtmp,False()))      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_33(l7#(x,y,res,tmp,mtmp,False()))       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_36(l8#(x,y,res,equal0(x,y),mtmp,t))     
          
             l8#(x,y,res,False(),mtmp,t) =  [1] y + [4]                               
                                         >= [1] y + [4]                               
                                         =  c_38(l10#(x,y,res,False(),mtmp,t))        
          
                                <(x,0()) =  [4]                                       
                                         >= [4]                                       
                                         =  False()                                   
          
                             <(0(),S(y)) =  [4]                                       
                                         >= [4]                                       
                                         =  True()                                    
          
                            <(S(x),S(y)) =  [4]                                       
                                         >= [4]                                       
                                         =  <(x,y)                                    
          
                           e1(a,b,res,t) =  [4]                                       
                                         >= [4]                                       
                                         =  e2(a,b,res,<(a,b))                        
          
                     e2(a,b,res,False()) =  [4]                                       
                                         >= [4]                                       
                                         =  False()                                   
          
                      e2(a,b,res,True()) =  [4]                                       
                                         >= [4]                                       
                                         =  e3(a,b,res,True())                        
          
                           e3(a,b,res,t) =  [4]                                       
                                         >= [4]                                       
                                         =  e4(a,b,res,<(b,a))                        
          
                     e4(a,b,res,False()) =  [4]                                       
                                         >= [4]                                       
                                         =  False()                                   
          
                      e4(a,b,res,True()) =  [4]                                       
                                         >= [4]                                       
                                         =  True()                                    
          
                             equal0(a,b) =  [4]                                       
                                         >= [4]                                       
                                         =  e1(a,b,False(),False())                   
          
                           m1(a,x,res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m2(a,x,res,False())                       
          
                     m2(a,b,res,False()) =  [0]                                       
                                         >= [0]                                       
                                         =  m4(a,b,res,False())                       
          
                    m4(S(x'),S(x),res,t) =  [0]                                       
                                         >= [0]                                       
                                         =  m5(S(x'),S(x),monus(x',x),t)              
          
                           m5(a,b,res,t) =  [1] res + [0]                             
                                         >= [1] res + [0]                             
                                         =  res                                       
          
                              monus(a,b) =  [0]                                       
                                         >= [0]                                       
                                         =  m1(a,b,False(),False())                   
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.a:13: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            gcd#(x,y) -> c_14(l1#(x,y,0(),False(),False(),False()))
            l1#(x,y,res,tmp,mtmp,t) -> c_18(l2#(x,y,res,tmp,mtmp,False()))
            l10#(x,y,res,tmp,mtmp,t) -> c_19(l11#(x,y,res,tmp,mtmp,<(x,y)))
            l11#(x,y,res,tmp,mtmp,False()) -> c_20(l14#(x,y,res,tmp,mtmp,False()))
            l11#(x,y,res,tmp,mtmp,True()) -> c_21(l12#(x,y,res,tmp,mtmp,True()))
            l12#(x,y,res,tmp,mtmp,t) -> c_22(l13#(x,y,res,tmp,monus(x,y),t))
            l13#(x,y,res,tmp,False(),t) -> c_23(gcd#(0(),y))
            l13#(x,y,res,tmp,True(),t) -> c_24(gcd#(S(0()),y))
            l14#(x,y,res,tmp,mtmp,t) -> c_25(l15#(x,y,res,tmp,monus(x,y),t))
            l15#(x,y,res,tmp,False(),t) -> c_26(gcd#(y,0()))
            l15#(x,y,res,tmp,True(),t) -> c_27(gcd#(y,S(0())))
            l2#(x,y,res,tmp,mtmp,False()) -> c_29(l3#(x,y,res,tmp,mtmp,False()))
            l3#(x,y,res,tmp,mtmp,t) -> c_31(l4#(x,y,0(),tmp,mtmp,t))
            l4#(x',x,res,tmp,mtmp,t) -> c_32(l5#(x',x,res,tmp,mtmp,False()))
            l5#(x,y,res,tmp,mtmp,False()) -> c_33(l7#(x,y,res,tmp,mtmp,False()))
            l7#(x,y,res,tmp,mtmp,t) -> c_36(l8#(x,y,res,equal0(x,y),mtmp,t))
            l8#(x,y,res,False(),mtmp,t) -> c_38(l10#(x,y,res,False(),mtmp,t))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/1,c_23/1,c_24/1,c_25/1,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

** Step 10.b:1: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
            l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
            l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
            l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
            l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
            l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
            l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
            l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
            l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
            l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
            l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
            l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
            l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
            l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
            l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
            l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_40) = {1},
            uargs(c_41) = {1},
            uargs(c_48) = {1},
            uargs(c_50) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                                    
                    p(<) = [0]                                    
                p(False) = [0]                                    
                    p(S) = [0]                                    
                 p(True) = [0]                                    
             p(bool2Nat) = [0]                                    
                   p(e1) = [1] x3 + [0]                           
                   p(e2) = [1] x3 + [1] x4 + [0]                  
                   p(e3) = [1] x3 + [0]                           
                   p(e4) = [1] x4 + [0]                           
                   p(e5) = [0]                                    
                   p(e6) = [0]                                    
                   p(e7) = [0]                                    
                   p(e8) = [0]                                    
               p(equal0) = [0]                                    
                  p(gcd) = [0]                                    
                p(help1) = [0]                                    
                   p(l1) = [0]                                    
                  p(l10) = [0]                                    
                  p(l11) = [0]                                    
                  p(l12) = [0]                                    
                  p(l13) = [0]                                    
                  p(l14) = [0]                                    
                  p(l15) = [0]                                    
                  p(l16) = [0]                                    
                   p(l2) = [0]                                    
                   p(l3) = [0]                                    
                   p(l4) = [0]                                    
                   p(l5) = [0]                                    
                   p(l6) = [0]                                    
                   p(l7) = [0]                                    
                   p(l8) = [0]                                    
                   p(l9) = [0]                                    
                   p(m1) = [0]                                    
                   p(m2) = [0]                                    
                   p(m3) = [0]                                    
                   p(m4) = [0]                                    
                   p(m5) = [1] x3 + [0]                           
                p(monus) = [0]                                    
                   p(<#) = [0]                                    
            p(bool2Nat#) = [0]                                    
                  p(e1#) = [0]                                    
                  p(e2#) = [0]                                    
                  p(e3#) = [0]                                    
                  p(e4#) = [0]                                    
                  p(e5#) = [0]                                    
                  p(e6#) = [0]                                    
                  p(e7#) = [0]                                    
                  p(e8#) = [0]                                    
              p(equal0#) = [0]                                    
                 p(gcd#) = [0]                                    
               p(help1#) = [0]                                    
                  p(l1#) = [4] x5 + [0]                           
                 p(l10#) = [0]                                    
                 p(l11#) = [1] x6 + [0]                           
                 p(l12#) = [0]                                    
                 p(l13#) = [1] x5 + [0]                           
                 p(l14#) = [0]                                    
                 p(l15#) = [1] x5 + [0]                           
                 p(l16#) = [0]                                    
                  p(l2#) = [4] x5 + [0]                           
                  p(l3#) = [0]                                    
                  p(l4#) = [0]                                    
                  p(l5#) = [0]                                    
                  p(l6#) = [1] x5 + [0]                           
                  p(l7#) = [0]                                    
                  p(l8#) = [1] x4 + [0]                           
                  p(l9#) = [0]                                    
                  p(m1#) = [1] x3 + [4]                           
                  p(m2#) = [2]                                    
                  p(m3#) = [1] x1 + [1] x2 + [1] x3 + [2] x4 + [4]
                  p(m4#) = [4] x4 + [5]                           
                  p(m5#) = [1] x3 + [4]                           
               p(monus#) = [0]                                    
                  p(c_1) = [0]                                    
                  p(c_2) = [4]                                    
                  p(c_3) = [2] x1 + [4] x2 + [1]                  
                  p(c_4) = [0]                                    
                  p(c_5) = [0]                                    
                  p(c_6) = [4] x2 + [2]                           
                  p(c_7) = [1]                                    
                  p(c_8) = [1]                                    
                  p(c_9) = [0]                                    
                 p(c_10) = [1]                                    
                 p(c_11) = [0]                                    
                 p(c_12) = [0]                                    
                 p(c_13) = [1] x1 + [0]                           
                 p(c_14) = [4] x1 + [0]                           
                 p(c_15) = [0]                                    
                 p(c_16) = [0]                                    
                 p(c_17) = [1]                                    
                 p(c_18) = [4] x1 + [0]                           
                 p(c_19) = [1] x1 + [0]                           
                 p(c_20) = [4] x1 + [0]                           
                 p(c_21) = [0]                                    
                 p(c_22) = [1] x1 + [1] x2 + [2]                  
                 p(c_23) = [0]                                    
                 p(c_24) = [2] x1 + [1]                           
                 p(c_25) = [0]                                    
                 p(c_26) = [4] x1 + [2]                           
                 p(c_27) = [2] x1 + [1]                           
                 p(c_28) = [1]                                    
                 p(c_29) = [1]                                    
                 p(c_30) = [1]                                    
                 p(c_31) = [4] x1 + [1]                           
                 p(c_32) = [1]                                    
                 p(c_33) = [0]                                    
                 p(c_34) = [2]                                    
                 p(c_35) = [4]                                    
                 p(c_36) = [1] x1 + [1]                           
                 p(c_37) = [0]                                    
                 p(c_38) = [0]                                    
                 p(c_39) = [2]                                    
                 p(c_40) = [1] x1 + [5]                           
                 p(c_41) = [1] x1 + [1]                           
                 p(c_42) = [2]                                    
                 p(c_43) = [0]                                    
                 p(c_44) = [0]                                    
                 p(c_45) = [2]                                    
                 p(c_46) = [0]                                    
                 p(c_47) = [2]                                    
                 p(c_48) = [1] x1 + [2]                           
                 p(c_49) = [0]                                    
                 p(c_50) = [1] x1 + [1]                           
                 p(c_51) = [0]                                    
                 p(c_52) = [4]                                    
                 p(c_53) = [0]                                    
          
          Following rules are strictly oriented:
          m4#(S(x'),S(x),res,t) = [4] t + [5]       
                                > [2]               
                                = c_48(monus#(x',x))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                 
                                         >= [0]                                 
                                         =  l1#(x,y,0(),False(),False(),False())
          
                 l1#(x,y,res,tmp,mtmp,t) =  [4] mtmp + [0]                      
                                         >= [4] mtmp + [0]                      
                                         =  l2#(x,y,res,tmp,mtmp,False())       
          
                l10#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l11#(x,y,res,tmp,mtmp,<(x,y))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l14#(x,y,res,tmp,mtmp,False())      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  l12#(x,y,res,tmp,mtmp,True())       
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l13#(x,y,res,tmp,monus(x,y),t)      
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l13#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(0(),y)                         
          
              l13#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(S(0()),y)                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l15#(x,y,res,tmp,monus(x,y),t)      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l15#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,0())                         
          
              l15#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,S(0()))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [4] mtmp + [0]                      
                                         >= [0]                                 
                                         =  l3#(x,y,res,tmp,mtmp,False())       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l4#(x,y,0(),tmp,mtmp,t)             
          
                l4#(x',x,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l5#(x',x,res,tmp,mtmp,False())      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l7#(x,y,res,tmp,mtmp,False())       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l8#(x,y,res,equal0(x,y),mtmp,t)     
          
             l8#(x,y,res,False(),mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l10#(x,y,res,False(),mtmp,t)        
          
                          m1#(a,x,res,t) =  [1] res + [4]                       
                                         >= [7]                                 
                                         =  c_40(m2#(a,x,res,False()))          
          
                    m2#(a,b,res,False()) =  [2]                                 
                                         >= [6]                                 
                                         =  c_41(m4#(a,b,res,False()))          
          
                             monus#(a,b) =  [0]                                 
                                         >= [5]                                 
                                         =  c_50(m1#(a,b,False(),False()))      
          
                                <(x,0()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                             <(0(),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                            <(S(x),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  <(x,y)                              
          
                           e1(a,b,res,t) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  e2(a,b,res,<(a,b))                  
          
                     e2(a,b,res,False()) =  [1] res + [0]                       
                                         >= [0]                                 
                                         =  False()                             
          
                      e2(a,b,res,True()) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  e3(a,b,res,True())                  
          
                           e3(a,b,res,t) =  [1] res + [0]                       
                                         >= [0]                                 
                                         =  e4(a,b,res,<(b,a))                  
          
                     e4(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                      e4(a,b,res,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                             equal0(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  e1(a,b,False(),False())             
          
                           m1(a,x,res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m2(a,x,res,False())                 
          
                     m2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  m4(a,b,res,False())                 
          
                    m4(S(x'),S(x),res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m5(S(x'),S(x),monus(x',x),t)        
          
                           m5(a,b,res,t) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  res                                 
          
                              monus(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  m1(a,b,False(),False())             
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.b:2: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
            l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
            l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
            l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
            l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
            l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
            l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
            l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
            l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
            l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
            l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
            l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
            l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
            l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
            l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
            l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_40) = {1},
            uargs(c_41) = {1},
            uargs(c_48) = {1},
            uargs(c_50) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [1]                  
                    p(<) = [0]                  
                p(False) = [0]                  
                    p(S) = [0]                  
                 p(True) = [0]                  
             p(bool2Nat) = [0]                  
                   p(e1) = [4] x4 + [0]         
                   p(e2) = [1] x4 + [0]         
                   p(e3) = [2] x4 + [0]         
                   p(e4) = [1] x4 + [0]         
                   p(e5) = [0]                  
                   p(e6) = [0]                  
                   p(e7) = [0]                  
                   p(e8) = [0]                  
               p(equal0) = [0]                  
                  p(gcd) = [0]                  
                p(help1) = [0]                  
                   p(l1) = [0]                  
                  p(l10) = [0]                  
                  p(l11) = [0]                  
                  p(l12) = [0]                  
                  p(l13) = [0]                  
                  p(l14) = [0]                  
                  p(l15) = [0]                  
                  p(l16) = [0]                  
                   p(l2) = [0]                  
                   p(l3) = [0]                  
                   p(l4) = [0]                  
                   p(l5) = [0]                  
                   p(l6) = [0]                  
                   p(l7) = [0]                  
                   p(l8) = [0]                  
                   p(l9) = [0]                  
                   p(m1) = [0]                  
                   p(m2) = [0]                  
                   p(m3) = [0]                  
                   p(m4) = [0]                  
                   p(m5) = [1] x3 + [0]         
                p(monus) = [0]                  
                   p(<#) = [0]                  
            p(bool2Nat#) = [0]                  
                  p(e1#) = [0]                  
                  p(e2#) = [1] x4 + [0]         
                  p(e3#) = [0]                  
                  p(e4#) = [0]                  
                  p(e5#) = [0]                  
                  p(e6#) = [0]                  
                  p(e7#) = [0]                  
                  p(e8#) = [0]                  
              p(equal0#) = [0]                  
                 p(gcd#) = [0]                  
               p(help1#) = [0]                  
                  p(l1#) = [0]                  
                 p(l10#) = [0]                  
                 p(l11#) = [1] x6 + [0]         
                 p(l12#) = [0]                  
                 p(l13#) = [1] x5 + [0]         
                 p(l14#) = [0]                  
                 p(l15#) = [1] x5 + [0]         
                 p(l16#) = [0]                  
                  p(l2#) = [0]                  
                  p(l3#) = [0]                  
                  p(l4#) = [0]                  
                  p(l5#) = [0]                  
                  p(l6#) = [0]                  
                  p(l7#) = [4] x6 + [0]         
                  p(l8#) = [1] x4 + [2] x6 + [0]
                  p(l9#) = [0]                  
                  p(m1#) = [5]                  
                  p(m2#) = [7]                  
                  p(m3#) = [0]                  
                  p(m4#) = [5]                  
                  p(m5#) = [2]                  
               p(monus#) = [0]                  
                  p(c_1) = [0]                  
                  p(c_2) = [0]                  
                  p(c_3) = [0]                  
                  p(c_4) = [0]                  
                  p(c_5) = [0]                  
                  p(c_6) = [0]                  
                  p(c_7) = [0]                  
                  p(c_8) = [1]                  
                  p(c_9) = [0]                  
                 p(c_10) = [0]                  
                 p(c_11) = [0]                  
                 p(c_12) = [0]                  
                 p(c_13) = [0]                  
                 p(c_14) = [0]                  
                 p(c_15) = [0]                  
                 p(c_16) = [0]                  
                 p(c_17) = [0]                  
                 p(c_18) = [0]                  
                 p(c_19) = [0]                  
                 p(c_20) = [0]                  
                 p(c_21) = [0]                  
                 p(c_22) = [0]                  
                 p(c_23) = [0]                  
                 p(c_24) = [0]                  
                 p(c_25) = [0]                  
                 p(c_26) = [0]                  
                 p(c_27) = [0]                  
                 p(c_28) = [0]                  
                 p(c_29) = [0]                  
                 p(c_30) = [0]                  
                 p(c_31) = [0]                  
                 p(c_32) = [0]                  
                 p(c_33) = [0]                  
                 p(c_34) = [0]                  
                 p(c_35) = [0]                  
                 p(c_36) = [0]                  
                 p(c_37) = [0]                  
                 p(c_38) = [0]                  
                 p(c_39) = [0]                  
                 p(c_40) = [1] x1 + [5]         
                 p(c_41) = [1] x1 + [1]         
                 p(c_42) = [0]                  
                 p(c_43) = [0]                  
                 p(c_44) = [0]                  
                 p(c_45) = [0]                  
                 p(c_46) = [0]                  
                 p(c_47) = [0]                  
                 p(c_48) = [1] x1 + [5]         
                 p(c_49) = [0]                  
                 p(c_50) = [1] x1 + [0]         
                 p(c_51) = [0]                  
                 p(c_52) = [0]                  
                 p(c_53) = [0]                  
          
          Following rules are strictly oriented:
          m2#(a,b,res,False()) = [7]                       
                               > [6]                       
                               = c_41(m4#(a,b,res,False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                 
                                         >= [0]                                 
                                         =  l1#(x,y,0(),False(),False(),False())
          
                 l1#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l2#(x,y,res,tmp,mtmp,False())       
          
                l10#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l11#(x,y,res,tmp,mtmp,<(x,y))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l14#(x,y,res,tmp,mtmp,False())      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  l12#(x,y,res,tmp,mtmp,True())       
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l13#(x,y,res,tmp,monus(x,y),t)      
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l13#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(0(),y)                         
          
              l13#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(S(0()),y)                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l15#(x,y,res,tmp,monus(x,y),t)      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l15#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,0())                         
          
              l15#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,S(0()))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l3#(x,y,res,tmp,mtmp,False())       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l4#(x,y,0(),tmp,mtmp,t)             
          
                l4#(x',x,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l5#(x',x,res,tmp,mtmp,False())      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l7#(x,y,res,tmp,mtmp,False())       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [4] t + [0]                         
                                         >= [2] t + [0]                         
                                         =  l8#(x,y,res,equal0(x,y),mtmp,t)     
          
             l8#(x,y,res,False(),mtmp,t) =  [2] t + [0]                         
                                         >= [0]                                 
                                         =  l10#(x,y,res,False(),mtmp,t)        
          
                          m1#(a,x,res,t) =  [5]                                 
                                         >= [12]                                
                                         =  c_40(m2#(a,x,res,False()))          
          
                   m4#(S(x'),S(x),res,t) =  [5]                                 
                                         >= [5]                                 
                                         =  c_48(monus#(x',x))                  
          
                             monus#(a,b) =  [0]                                 
                                         >= [5]                                 
                                         =  c_50(m1#(a,b,False(),False()))      
          
                                <(x,0()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                             <(0(),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                            <(S(x),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  <(x,y)                              
          
                           e1(a,b,res,t) =  [4] t + [0]                         
                                         >= [0]                                 
                                         =  e2(a,b,res,<(a,b))                  
          
                     e2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                      e2(a,b,res,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  e3(a,b,res,True())                  
          
                           e3(a,b,res,t) =  [2] t + [0]                         
                                         >= [0]                                 
                                         =  e4(a,b,res,<(b,a))                  
          
                     e4(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                      e4(a,b,res,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                             equal0(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  e1(a,b,False(),False())             
          
                           m1(a,x,res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m2(a,x,res,False())                 
          
                     m2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  m4(a,b,res,False())                 
          
                    m4(S(x'),S(x),res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m5(S(x'),S(x),monus(x',x),t)        
          
                           m5(a,b,res,t) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  res                                 
          
                              monus(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  m1(a,b,False(),False())             
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.b:3: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
            l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
            l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
            l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
            l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
            l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
            l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
            l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
            l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
            l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
            l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
            l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
            l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
            l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
            l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
            l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_40) = {1},
            uargs(c_41) = {1},
            uargs(c_48) = {1},
            uargs(c_50) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                           
                    p(<) = [0]                           
                p(False) = [0]                           
                    p(S) = [0]                           
                 p(True) = [0]                           
             p(bool2Nat) = [1] x1 + [1]                  
                   p(e1) = [1] x4 + [0]                  
                   p(e2) = [1] x4 + [0]                  
                   p(e3) = [1] x4 + [0]                  
                   p(e4) = [1] x4 + [0]                  
                   p(e5) = [2] x1 + [4] x2 + [1] x3 + [4]
                   p(e6) = [1] x1 + [0]                  
                   p(e7) = [0]                           
                   p(e8) = [0]                           
               p(equal0) = [0]                           
                  p(gcd) = [0]                           
                p(help1) = [0]                           
                   p(l1) = [0]                           
                  p(l10) = [0]                           
                  p(l11) = [0]                           
                  p(l12) = [0]                           
                  p(l13) = [0]                           
                  p(l14) = [0]                           
                  p(l15) = [0]                           
                  p(l16) = [0]                           
                   p(l2) = [0]                           
                   p(l3) = [0]                           
                   p(l4) = [0]                           
                   p(l5) = [0]                           
                   p(l6) = [0]                           
                   p(l7) = [0]                           
                   p(l8) = [0]                           
                   p(l9) = [0]                           
                   p(m1) = [0]                           
                   p(m2) = [0]                           
                   p(m3) = [0]                           
                   p(m4) = [0]                           
                   p(m5) = [1] x3 + [0]                  
                p(monus) = [0]                           
                   p(<#) = [0]                           
            p(bool2Nat#) = [0]                           
                  p(e1#) = [0]                           
                  p(e2#) = [0]                           
                  p(e3#) = [0]                           
                  p(e4#) = [0]                           
                  p(e5#) = [0]                           
                  p(e6#) = [0]                           
                  p(e7#) = [0]                           
                  p(e8#) = [0]                           
              p(equal0#) = [0]                           
                 p(gcd#) = [0]                           
               p(help1#) = [0]                           
                  p(l1#) = [0]                           
                 p(l10#) = [0]                           
                 p(l11#) = [1] x6 + [0]                  
                 p(l12#) = [0]                           
                 p(l13#) = [1] x5 + [0]                  
                 p(l14#) = [0]                           
                 p(l15#) = [1] x5 + [0]                  
                 p(l16#) = [0]                           
                  p(l2#) = [0]                           
                  p(l3#) = [0]                           
                  p(l4#) = [0]                           
                  p(l5#) = [0]                           
                  p(l6#) = [0]                           
                  p(l7#) = [0]                           
                  p(l8#) = [1] x4 + [0]                  
                  p(l9#) = [0]                           
                  p(m1#) = [7]                           
                  p(m2#) = [0]                           
                  p(m3#) = [0]                           
                  p(m4#) = [1] x4 + [0]                  
                  p(m5#) = [0]                           
               p(monus#) = [0]                           
                  p(c_1) = [0]                           
                  p(c_2) = [0]                           
                  p(c_3) = [0]                           
                  p(c_4) = [0]                           
                  p(c_5) = [0]                           
                  p(c_6) = [0]                           
                  p(c_7) = [0]                           
                  p(c_8) = [0]                           
                  p(c_9) = [0]                           
                 p(c_10) = [0]                           
                 p(c_11) = [0]                           
                 p(c_12) = [0]                           
                 p(c_13) = [0]                           
                 p(c_14) = [0]                           
                 p(c_15) = [0]                           
                 p(c_16) = [0]                           
                 p(c_17) = [0]                           
                 p(c_18) = [0]                           
                 p(c_19) = [0]                           
                 p(c_20) = [0]                           
                 p(c_21) = [0]                           
                 p(c_22) = [0]                           
                 p(c_23) = [0]                           
                 p(c_24) = [0]                           
                 p(c_25) = [0]                           
                 p(c_26) = [0]                           
                 p(c_27) = [0]                           
                 p(c_28) = [0]                           
                 p(c_29) = [0]                           
                 p(c_30) = [0]                           
                 p(c_31) = [2] x1 + [0]                  
                 p(c_32) = [0]                           
                 p(c_33) = [0]                           
                 p(c_34) = [0]                           
                 p(c_35) = [0]                           
                 p(c_36) = [0]                           
                 p(c_37) = [0]                           
                 p(c_38) = [0]                           
                 p(c_39) = [0]                           
                 p(c_40) = [1] x1 + [0]                  
                 p(c_41) = [1] x1 + [0]                  
                 p(c_42) = [0]                           
                 p(c_43) = [0]                           
                 p(c_44) = [0]                           
                 p(c_45) = [0]                           
                 p(c_46) = [0]                           
                 p(c_47) = [0]                           
                 p(c_48) = [1] x1 + [0]                  
                 p(c_49) = [0]                           
                 p(c_50) = [1] x1 + [0]                  
                 p(c_51) = [0]                           
                 p(c_52) = [0]                           
                 p(c_53) = [0]                           
          
          Following rules are strictly oriented:
          m1#(a,x,res,t) = [7]                       
                         > [0]                       
                         = c_40(m2#(a,x,res,False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [0]                                 
                                         >= [0]                                 
                                         =  l1#(x,y,0(),False(),False(),False())
          
                 l1#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l2#(x,y,res,tmp,mtmp,False())       
          
                l10#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l11#(x,y,res,tmp,mtmp,<(x,y))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l14#(x,y,res,tmp,mtmp,False())      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  l12#(x,y,res,tmp,mtmp,True())       
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l13#(x,y,res,tmp,monus(x,y),t)      
          
                l12#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l13#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(0(),y)                         
          
              l13#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(S(0()),y)                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l15#(x,y,res,tmp,monus(x,y),t)      
          
                l14#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  monus#(x,y)                         
          
             l15#(x,y,res,tmp,False(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,0())                         
          
              l15#(x,y,res,tmp,True(),t) =  [0]                                 
                                         >= [0]                                 
                                         =  gcd#(y,S(0()))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l3#(x,y,res,tmp,mtmp,False())       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l4#(x,y,0(),tmp,mtmp,t)             
          
                l4#(x',x,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l5#(x',x,res,tmp,mtmp,False())      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  l7#(x,y,res,tmp,mtmp,False())       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l8#(x,y,res,equal0(x,y),mtmp,t)     
          
             l8#(x,y,res,False(),mtmp,t) =  [0]                                 
                                         >= [0]                                 
                                         =  l10#(x,y,res,False(),mtmp,t)        
          
                    m2#(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  c_41(m4#(a,b,res,False()))          
          
                   m4#(S(x'),S(x),res,t) =  [1] t + [0]                         
                                         >= [0]                                 
                                         =  c_48(monus#(x',x))                  
          
                             monus#(a,b) =  [0]                                 
                                         >= [7]                                 
                                         =  c_50(m1#(a,b,False(),False()))      
          
                                <(x,0()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                             <(0(),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                            <(S(x),S(y)) =  [0]                                 
                                         >= [0]                                 
                                         =  <(x,y)                              
          
                           e1(a,b,res,t) =  [1] t + [0]                         
                                         >= [0]                                 
                                         =  e2(a,b,res,<(a,b))                  
          
                     e2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                      e2(a,b,res,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  e3(a,b,res,True())                  
          
                           e3(a,b,res,t) =  [1] t + [0]                         
                                         >= [0]                                 
                                         =  e4(a,b,res,<(b,a))                  
          
                     e4(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  False()                             
          
                      e4(a,b,res,True()) =  [0]                                 
                                         >= [0]                                 
                                         =  True()                              
          
                             equal0(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  e1(a,b,False(),False())             
          
                           m1(a,x,res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m2(a,x,res,False())                 
          
                     m2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  m4(a,b,res,False())                 
          
                    m4(S(x'),S(x),res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m5(S(x'),S(x),monus(x',x),t)        
          
                           m5(a,b,res,t) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  res                                 
          
                              monus(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  m1(a,b,False(),False())             
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.b:4: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict DPs:
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak DPs:
            gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
            l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
            l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
            l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
            l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
            l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
            l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
            l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
            l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
            l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
            l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
            l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
            l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
            l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
            l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
            l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following constant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(e2) = {4},
            uargs(e4) = {4},
            uargs(m5) = {3},
            uargs(l11#) = {6},
            uargs(l13#) = {5},
            uargs(l15#) = {5},
            uargs(l8#) = {4},
            uargs(c_40) = {1},
            uargs(c_41) = {1},
            uargs(c_48) = {1},
            uargs(c_50) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                    p(0) = [0]                                                      
                    p(<) = [4]                                                      
                p(False) = [4]                                                      
                    p(S) = [1] x1 + [1]                                             
                 p(True) = [4]                                                      
             p(bool2Nat) = [1] x1 + [0]                                             
                   p(e1) = [4]                                                      
                   p(e2) = [1] x4 + [0]                                             
                   p(e3) = [4]                                                      
                   p(e4) = [1] x4 + [0]                                             
                   p(e5) = [1] x2 + [1] x4 + [4]                                    
                   p(e6) = [1] x1 + [4] x2 + [4] x3 + [1] x4 + [1]                  
                   p(e7) = [4] x1 + [4] x2 + [1] x3 + [1]                           
                   p(e8) = [4] x1 + [1] x2 + [1] x3 + [2] x4 + [1]                  
               p(equal0) = [4]                                                      
                  p(gcd) = [1] x1 + [4]                                             
                p(help1) = [1] x1 + [0]                                             
                   p(l1) = [1] x1 + [1] x3 + [1] x4 + [2] x5 + [1] x6 + [2]         
                  p(l10) = [1] x2 + [2] x3 + [1] x4 + [0]                           
                  p(l11) = [1] x1 + [1] x2 + [4] x3 + [2] x4 + [1] x6 + [0]         
                  p(l12) = [1] x1 + [4] x2 + [1] x3 + [1] x4 + [4] x5 + [1] x6 + [1]
                  p(l13) = [4] x1 + [4] x2 + [2] x3 + [1] x6 + [0]                  
                  p(l14) = [2] x3 + [2] x5 + [1] x6 + [1]                           
                  p(l15) = [4] x2 + [4] x3 + [2] x4 + [1] x5 + [4] x6 + [0]         
                  p(l16) = [1] x4 + [2] x6 + [0]                                    
                   p(l2) = [4] x1 + [4] x3 + [1] x4 + [4]                           
                   p(l3) = [1] x1 + [1] x2 + [4] x3 + [0]                           
                   p(l4) = [2] x4 + [1] x5 + [1]                                    
                   p(l5) = [1] x2 + [2] x3 + [1] x4 + [1] x6 + [1]                  
                   p(l6) = [0]                                                      
                   p(l7) = [0]                                                      
                   p(l8) = [0]                                                      
                   p(l9) = [2] x2 + [0]                                             
                   p(m1) = [0]                                                      
                   p(m2) = [0]                                                      
                   p(m3) = [0]                                                      
                   p(m4) = [0]                                                      
                   p(m5) = [1] x3 + [0]                                             
                p(monus) = [0]                                                      
                   p(<#) = [0]                                                      
            p(bool2Nat#) = [0]                                                      
                  p(e1#) = [0]                                                      
                  p(e2#) = [0]                                                      
                  p(e3#) = [0]                                                      
                  p(e4#) = [0]                                                      
                  p(e5#) = [2] x3 + [0]                                             
                  p(e6#) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [4]                  
                  p(e7#) = [1] x3 + [2] x4 + [4]                                    
                  p(e8#) = [4] x1 + [2] x2 + [1] x3 + [0]                           
              p(equal0#) = [4] x1 + [1] x2 + [0]                                    
                 p(gcd#) = [1] x1 + [1] x2 + [4]                                    
               p(help1#) = [1] x1 + [0]                                             
                  p(l1#) = [1] x1 + [1] x2 + [2] x3 + [4]                           
                 p(l10#) = [1] x1 + [1] x2 + [4]                                    
                 p(l11#) = [1] x1 + [1] x2 + [1] x6 + [0]                           
                 p(l12#) = [1] x1 + [1] x2 + [4]                                    
                 p(l13#) = [1] x1 + [1] x2 + [1] x5 + [4]                           
                 p(l14#) = [1] x1 + [1] x2 + [1]                                    
                 p(l15#) = [1] x2 + [1] x5 + [1]                                    
                 p(l16#) = [1] x2 + [1] x3 + [4] x4 + [1] x6 + [0]                  
                  p(l2#) = [1] x1 + [1] x2 + [2] x3 + [1] x6 + [0]                  
                  p(l3#) = [1] x1 + [1] x2 + [1] x3 + [4]                           
                  p(l4#) = [1] x1 + [1] x2 + [2] x3 + [4]                           
                  p(l5#) = [1] x1 + [1] x2 + [2] x3 + [1] x6 + [0]                  
                  p(l6#) = [4] x1 + [1] x4 + [1] x5 + [1] x6 + [0]                  
                  p(l7#) = [1] x1 + [1] x2 + [2] x3 + [4]                           
                  p(l8#) = [1] x1 + [1] x2 + [1] x4 + [0]                           
                  p(l9#) = [4] x3 + [1] x4 + [2] x5 + [1]                           
                  p(m1#) = [1] x1 + [0]                                             
                  p(m2#) = [1] x1 + [0]                                             
                  p(m3#) = [1] x1 + [1] x2 + [1] x4 + [4]                           
                  p(m4#) = [1] x1 + [0]                                             
                  p(m5#) = [1] x1 + [1] x2 + [4] x3 + [2]                           
               p(monus#) = [1] x1 + [1]                                             
                  p(c_1) = [0]                                                      
                  p(c_2) = [0]                                                      
                  p(c_3) = [1]                                                      
                  p(c_4) = [0]                                                      
                  p(c_5) = [1] x1 + [2]                                             
                  p(c_6) = [1] x1 + [1] x2 + [1]                                    
                  p(c_7) = [2]                                                      
                  p(c_8) = [0]                                                      
                  p(c_9) = [0]                                                      
                 p(c_10) = [1]                                                      
                 p(c_11) = [0]                                                      
                 p(c_12) = [0]                                                      
                 p(c_13) = [4]                                                      
                 p(c_14) = [1]                                                      
                 p(c_15) = [0]                                                      
                 p(c_16) = [1]                                                      
                 p(c_17) = [0]                                                      
                 p(c_18) = [1]                                                      
                 p(c_19) = [0]                                                      
                 p(c_20) = [1] x1 + [0]                                             
                 p(c_21) = [1]                                                      
                 p(c_22) = [1] x1 + [1] x2 + [0]                                    
                 p(c_23) = [4] x1 + [0]                                             
                 p(c_24) = [1] x1 + [0]                                             
                 p(c_25) = [1] x2 + [2]                                             
                 p(c_26) = [2] x1 + [1]                                             
                 p(c_27) = [0]                                                      
                 p(c_28) = [4]                                                      
                 p(c_29) = [2] x1 + [0]                                             
                 p(c_30) = [0]                                                      
                 p(c_31) = [0]                                                      
                 p(c_32) = [1] x1 + [1]                                             
                 p(c_33) = [2] x1 + [0]                                             
                 p(c_34) = [0]                                                      
                 p(c_35) = [1]                                                      
                 p(c_36) = [2] x1 + [1]                                             
                 p(c_37) = [0]                                                      
                 p(c_38) = [0]                                                      
                 p(c_39) = [1]                                                      
                 p(c_40) = [1] x1 + [0]                                             
                 p(c_41) = [1] x1 + [0]                                             
                 p(c_42) = [0]                                                      
                 p(c_43) = [4]                                                      
                 p(c_44) = [1]                                                      
                 p(c_45) = [2]                                                      
                 p(c_46) = [1]                                                      
                 p(c_47) = [2]                                                      
                 p(c_48) = [1] x1 + [0]                                             
                 p(c_49) = [1]                                                      
                 p(c_50) = [1] x1 + [0]                                             
                 p(c_51) = [0]                                                      
                 p(c_52) = [0]                                                      
                 p(c_53) = [4] x1 + [0]                                             
          
          Following rules are strictly oriented:
          monus#(a,b) = [1] a + [1]                   
                      > [1] a + [0]                   
                      = c_50(m1#(a,b,False(),False()))
          
          
          Following rules are (at-least) weakly oriented:
                               gcd#(x,y) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [4]                 
                                         =  l1#(x,y,0(),False(),False(),False())
          
                 l1#(x,y,res,tmp,mtmp,t) =  [2] res + [1] x + [1] y + [4]       
                                         >= [2] res + [1] x + [1] y + [4]       
                                         =  l2#(x,y,res,tmp,mtmp,False())       
          
                l10#(x,y,res,tmp,mtmp,t) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [4]                 
                                         =  l11#(x,y,res,tmp,mtmp,<(x,y))       
          
          l11#(x,y,res,tmp,mtmp,False()) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [1]                 
                                         =  l14#(x,y,res,tmp,mtmp,False())      
          
           l11#(x,y,res,tmp,mtmp,True()) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [4]                 
                                         =  l12#(x,y,res,tmp,mtmp,True())       
          
                l12#(x,y,res,tmp,mtmp,t) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [4]                 
                                         =  l13#(x,y,res,tmp,monus(x,y),t)      
          
                l12#(x,y,res,tmp,mtmp,t) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1]                         
                                         =  monus#(x,y)                         
          
             l13#(x,y,res,tmp,False(),t) =  [1] x + [1] y + [8]                 
                                         >= [1] y + [4]                         
                                         =  gcd#(0(),y)                         
          
              l13#(x,y,res,tmp,True(),t) =  [1] x + [1] y + [8]                 
                                         >= [1] y + [5]                         
                                         =  gcd#(S(0()),y)                      
          
                l14#(x,y,res,tmp,mtmp,t) =  [1] x + [1] y + [1]                 
                                         >= [1] y + [1]                         
                                         =  l15#(x,y,res,tmp,monus(x,y),t)      
          
                l14#(x,y,res,tmp,mtmp,t) =  [1] x + [1] y + [1]                 
                                         >= [1] x + [1]                         
                                         =  monus#(x,y)                         
          
             l15#(x,y,res,tmp,False(),t) =  [1] y + [5]                         
                                         >= [1] y + [4]                         
                                         =  gcd#(y,0())                         
          
              l15#(x,y,res,tmp,True(),t) =  [1] y + [5]                         
                                         >= [1] y + [5]                         
                                         =  gcd#(y,S(0()))                      
          
           l2#(x,y,res,tmp,mtmp,False()) =  [2] res + [1] x + [1] y + [4]       
                                         >= [1] res + [1] x + [1] y + [4]       
                                         =  l3#(x,y,res,tmp,mtmp,False())       
          
                 l3#(x,y,res,tmp,mtmp,t) =  [1] res + [1] x + [1] y + [4]       
                                         >= [1] x + [1] y + [4]                 
                                         =  l4#(x,y,0(),tmp,mtmp,t)             
          
                l4#(x',x,res,tmp,mtmp,t) =  [2] res + [1] x + [1] x' + [4]      
                                         >= [2] res + [1] x + [1] x' + [4]      
                                         =  l5#(x',x,res,tmp,mtmp,False())      
          
           l5#(x,y,res,tmp,mtmp,False()) =  [2] res + [1] x + [1] y + [4]       
                                         >= [2] res + [1] x + [1] y + [4]       
                                         =  l7#(x,y,res,tmp,mtmp,False())       
          
                 l7#(x,y,res,tmp,mtmp,t) =  [2] res + [1] x + [1] y + [4]       
                                         >= [1] x + [1] y + [4]                 
                                         =  l8#(x,y,res,equal0(x,y),mtmp,t)     
          
             l8#(x,y,res,False(),mtmp,t) =  [1] x + [1] y + [4]                 
                                         >= [1] x + [1] y + [4]                 
                                         =  l10#(x,y,res,False(),mtmp,t)        
          
                          m1#(a,x,res,t) =  [1] a + [0]                         
                                         >= [1] a + [0]                         
                                         =  c_40(m2#(a,x,res,False()))          
          
                    m2#(a,b,res,False()) =  [1] a + [0]                         
                                         >= [1] a + [0]                         
                                         =  c_41(m4#(a,b,res,False()))          
          
                   m4#(S(x'),S(x),res,t) =  [1] x' + [1]                        
                                         >= [1] x' + [1]                        
                                         =  c_48(monus#(x',x))                  
          
                                <(x,0()) =  [4]                                 
                                         >= [4]                                 
                                         =  False()                             
          
                             <(0(),S(y)) =  [4]                                 
                                         >= [4]                                 
                                         =  True()                              
          
                            <(S(x),S(y)) =  [4]                                 
                                         >= [4]                                 
                                         =  <(x,y)                              
          
                           e1(a,b,res,t) =  [4]                                 
                                         >= [4]                                 
                                         =  e2(a,b,res,<(a,b))                  
          
                     e2(a,b,res,False()) =  [4]                                 
                                         >= [4]                                 
                                         =  False()                             
          
                      e2(a,b,res,True()) =  [4]                                 
                                         >= [4]                                 
                                         =  e3(a,b,res,True())                  
          
                           e3(a,b,res,t) =  [4]                                 
                                         >= [4]                                 
                                         =  e4(a,b,res,<(b,a))                  
          
                     e4(a,b,res,False()) =  [4]                                 
                                         >= [4]                                 
                                         =  False()                             
          
                      e4(a,b,res,True()) =  [4]                                 
                                         >= [4]                                 
                                         =  True()                              
          
                             equal0(a,b) =  [4]                                 
                                         >= [4]                                 
                                         =  e1(a,b,False(),False())             
          
                           m1(a,x,res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m2(a,x,res,False())                 
          
                     m2(a,b,res,False()) =  [0]                                 
                                         >= [0]                                 
                                         =  m4(a,b,res,False())                 
          
                    m4(S(x'),S(x),res,t) =  [0]                                 
                                         >= [0]                                 
                                         =  m5(S(x'),S(x),monus(x',x),t)        
          
                           m5(a,b,res,t) =  [1] res + [0]                       
                                         >= [1] res + [0]                       
                                         =  res                                 
          
                              monus(a,b) =  [0]                                 
                                         >= [0]                                 
                                         =  m1(a,b,False(),False())             
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
** Step 10.b:5: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak DPs:
            gcd#(x,y) -> l1#(x,y,0(),False(),False(),False())
            l1#(x,y,res,tmp,mtmp,t) -> l2#(x,y,res,tmp,mtmp,False())
            l10#(x,y,res,tmp,mtmp,t) -> l11#(x,y,res,tmp,mtmp,<(x,y))
            l11#(x,y,res,tmp,mtmp,False()) -> l14#(x,y,res,tmp,mtmp,False())
            l11#(x,y,res,tmp,mtmp,True()) -> l12#(x,y,res,tmp,mtmp,True())
            l12#(x,y,res,tmp,mtmp,t) -> l13#(x,y,res,tmp,monus(x,y),t)
            l12#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l13#(x,y,res,tmp,False(),t) -> gcd#(0(),y)
            l13#(x,y,res,tmp,True(),t) -> gcd#(S(0()),y)
            l14#(x,y,res,tmp,mtmp,t) -> l15#(x,y,res,tmp,monus(x,y),t)
            l14#(x,y,res,tmp,mtmp,t) -> monus#(x,y)
            l15#(x,y,res,tmp,False(),t) -> gcd#(y,0())
            l15#(x,y,res,tmp,True(),t) -> gcd#(y,S(0()))
            l2#(x,y,res,tmp,mtmp,False()) -> l3#(x,y,res,tmp,mtmp,False())
            l3#(x,y,res,tmp,mtmp,t) -> l4#(x,y,0(),tmp,mtmp,t)
            l4#(x',x,res,tmp,mtmp,t) -> l5#(x',x,res,tmp,mtmp,False())
            l5#(x,y,res,tmp,mtmp,False()) -> l7#(x,y,res,tmp,mtmp,False())
            l7#(x,y,res,tmp,mtmp,t) -> l8#(x,y,res,equal0(x,y),mtmp,t)
            l8#(x,y,res,False(),mtmp,t) -> l10#(x,y,res,False(),mtmp,t)
            m1#(a,x,res,t) -> c_40(m2#(a,x,res,False()))
            m2#(a,b,res,False()) -> c_41(m4#(a,b,res,False()))
            m4#(S(x'),S(x),res,t) -> c_48(monus#(x',x))
            monus#(a,b) -> c_50(m1#(a,b,False(),False()))
        - Weak TRS:
            <(x,0()) -> False()
            <(0(),S(y)) -> True()
            <(S(x),S(y)) -> <(x,y)
            e1(a,b,res,t) -> e2(a,b,res,<(a,b))
            e2(a,b,res,False()) -> False()
            e2(a,b,res,True()) -> e3(a,b,res,True())
            e3(a,b,res,t) -> e4(a,b,res,<(b,a))
            e4(a,b,res,False()) -> False()
            e4(a,b,res,True()) -> True()
            equal0(a,b) -> e1(a,b,False(),False())
            m1(a,x,res,t) -> m2(a,x,res,False())
            m2(a,b,res,False()) -> m4(a,b,res,False())
            m4(S(x'),S(x),res,t) -> m5(S(x'),S(x),monus(x',x),t)
            m5(a,b,res,t) -> res
            monus(a,b) -> m1(a,b,False(),False())
        - Signature:
            {</2,bool2Nat/1,e1/4,e2/4,e3/4,e4/4,e5/4,e6/4,e7/4,e8/4,equal0/2,gcd/2,help1/1,l1/6,l10/6,l11/6,l12/6,l13/6
            ,l14/6,l15/6,l16/6,l2/6,l3/6,l4/6,l5/6,l6/6,l7/6,l8/6,l9/6,m1/4,m2/4,m3/4,m4/4,m5/4,monus/2,<#/2,bool2Nat#/1
            ,e1#/4,e2#/4,e3#/4,e4#/4,e5#/4,e6#/4,e7#/4,e8#/4,equal0#/2,gcd#/2,help1#/1,l1#/6,l10#/6,l11#/6,l12#/6,l13#/6
            ,l14#/6,l15#/6,l16#/6,l2#/6,l3#/6,l4#/6,l5#/6,l6#/6,l7#/6,l8#/6,l9#/6,m1#/4,m2#/4,m3#/4,m4#/4,m5#/4
            ,monus#/2} / {0/0,False/0,S/1,True/0,c_1/0,c_2/0,c_3/2,c_4/0,c_5/1,c_6/2,c_7/0,c_8/0,c_9/0,c_10/0,c_11/0
            ,c_12/0,c_13/1,c_14/1,c_15/0,c_16/0,c_17/0,c_18/1,c_19/1,c_20/1,c_21/1,c_22/2,c_23/1,c_24/1,c_25/2,c_26/1
            ,c_27/1,c_28/0,c_29/1,c_30/0,c_31/1,c_32/1,c_33/1,c_34/0,c_35/0,c_36/1,c_37/0,c_38/1,c_39/0,c_40/1,c_41/1
            ,c_42/0,c_43/0,c_44/0,c_45/0,c_46/0,c_47/0,c_48/1,c_49/0,c_50/1,c_51/0,c_52/0,c_53/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {<#,bool2Nat#,e1#,e2#,e3#,e4#,e5#,e6#,e7#,e8#,equal0#,gcd#
            ,help1#,l1#,l10#,l11#,l12#,l13#,l14#,l15#,l16#,l2#,l3#,l4#,l5#,l6#,l7#,l8#,l9#,m1#,m2#,m3#,m4#,m5#
            ,monus#} and constructors {0,False,S,True}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^2))