MAYBE
* Step 1: ArgumentFilter MAYBE
    + Considered Problem:
        Rules:
          0. f0(A,B,C,D,E,F,G,H,I,J)  -> f31(1,B,C,D,E,K,0,1,L,L) [K >= 1 && 0 >= L]                                                                                  (1,1)
          1. f0(A,B,C,D,E,F,G,H,I,J)  -> f18(1,B,C,D,E,K,0,1,L,L) [K >= 1 && L >= 1]                                                                                  (1,1)
          2. f0(A,B,C,D,E,F,G,H,I,J)  -> f18(1,B,C,D,E,K,K,H,I,J) [0 >= K]                                                                                            (1,1)
          3. f31(A,B,C,D,E,F,G,H,I,J) -> f31(A,B,C,D,E,F,G,H,I,J) [-1*G >= 0 && A + -1*G >= 0 && 1 + -1*A + -1*G >= 0 && 1 + -1*A >= 0 && A >= 0]                     (?,1)
          4. f18(A,B,C,D,E,F,G,H,I,J) -> f24(0,B,K,D,K,F,G,H,I,J) [-1*G >= 0 && -1 + A + -1*G >= 0 && 1 + -1*A + -1*G >= 0 && 1 + -1*A >= 0 && -1 + A >= 0 && A >= 1] (?,1)
          5. f24(A,B,C,D,E,F,G,H,I,J) -> f31(1,L,C,K,E,F,G,H,I,J) [-1*G >= 0 && A + -1*G >= 0 && -1*A + -1*G >= 0 && -1*A >= 0 && A >= 0 && 0 >= A && K >= 1000 + C]  (?,1)
          6. f24(A,B,C,D,E,F,G,H,I,J) -> f31(A,L,C,K,E,F,G,H,I,J) [-1*G >= 0 && A + -1*G >= 0 && -1*A + -1*G >= 0 && -1*A >= 0 && A >= 0 && 0 >= A && 999 + C >= K]   (?,1)
        Signature:
          {(f0,10);(f18,10);(f24,10);(f31,10)}
        Flow Graph:
          [0->{3},1->{4},2->{4},3->{3},4->{5,6},5->{3},6->{3}]
        
    + Applied Processor:
        ArgumentFilter [1,3,4,5,7,8,9]
    + Details:
        We remove following argument positions: [1,3,4,5,7,8,9].
* Step 2: FromIts MAYBE
    + Considered Problem:
        Rules:
          0. f0(A,C,G)  -> f31(1,C,0) [K >= 1 && 0 >= L]                                                                                  (1,1)
          1. f0(A,C,G)  -> f18(1,C,0) [K >= 1 && L >= 1]                                                                                  (1,1)
          2. f0(A,C,G)  -> f18(1,C,K) [0 >= K]                                                                                            (1,1)
          3. f31(A,C,G) -> f31(A,C,G) [-1*G >= 0 && A + -1*G >= 0 && 1 + -1*A + -1*G >= 0 && 1 + -1*A >= 0 && A >= 0]                     (?,1)
          4. f18(A,C,G) -> f24(0,K,G) [-1*G >= 0 && -1 + A + -1*G >= 0 && 1 + -1*A + -1*G >= 0 && 1 + -1*A >= 0 && -1 + A >= 0 && A >= 1] (?,1)
          5. f24(A,C,G) -> f31(1,C,G) [-1*G >= 0 && A + -1*G >= 0 && -1*A + -1*G >= 0 && -1*A >= 0 && A >= 0 && 0 >= A && K >= 1000 + C]  (?,1)
          6. f24(A,C,G) -> f31(A,C,G) [-1*G >= 0 && A + -1*G >= 0 && -1*A + -1*G >= 0 && -1*A >= 0 && A >= 0 && 0 >= A && 999 + C >= K]   (?,1)
        Signature:
          {(f0,10);(f18,10);(f24,10);(f31,10)}
        Flow Graph:
          [0->{3},1->{4},2->{4},3->{3},4->{5,6},5->{3},6->{3}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 3: AddSinks MAYBE
    + Considered Problem:
        Rules:
          f0(A,C,G)  -> f31(1,C,0)  [K >= 1 && 0 >= L]
          f0(A,C,G)  -> f18(1,C,0)  [K >= 1 && L >= 1]
          f0(A,C,G)  -> f18(1,C,K)  [0 >= K]
          f31(A,C,G) -> f31(A,C,G)  [-1*G >= 0 && A + -1*G >= 0 && 1 + -1*A + -1*G >= 0 && 1 + -1*A >= 0 && A >= 0]
          f18(A,C,G) -> f24(0,K,G)  [-1*G >= 0
                                     && -1 + A + -1*G >= 0
                                     && 1 + -1*A + -1*G >= 0
                                     && 1 + -1*A >= 0
                                     && -1 + A >= 0
                                     && A >= 1]
          f24(A,C,G) -> f31(1,C,G)  [-1*G >= 0
                                     && A + -1*G >= 0
                                     && -1*A + -1*G >= 0
                                     && -1*A >= 0
                                     && A >= 0
                                     && 0 >= A
                                     && K >= 1000 + C]
          f24(A,C,G) -> f31(A,C,G)  [-1*G >= 0
                                     && A + -1*G >= 0
                                     && -1*A + -1*G >= 0
                                     && -1*A >= 0
                                     && A >= 0
                                     && 0 >= A
                                     && 999 + C >= K]
        Signature:
          {(f0,10);(f18,10);(f24,10);(f31,10)}
        Rule Graph:
          [0->{3},1->{4},2->{4},3->{3},4->{5,6},5->{3},6->{3}]
    + Applied Processor:
        AddSinks
    + Details:
        ()
* Step 4: Failure MAYBE
  + Considered Problem:
      Rules:
        f0(A,C,G)  -> f31(1,C,0)        [K >= 1 && 0 >= L]
        f0(A,C,G)  -> f18(1,C,0)        [K >= 1 && L >= 1]
        f0(A,C,G)  -> f18(1,C,K)        [0 >= K]
        f31(A,C,G) -> f31(A,C,G)        [-1*G >= 0
                                         && A + -1*G >= 0
                                         && 1 + -1*A + -1*G >= 0
                                         && 1 + -1*A >= 0
                                         && A >= 0]
        f18(A,C,G) -> f24(0,K,G)        [-1*G >= 0
                                         && -1 + A + -1*G >= 0
                                         && 1 + -1*A + -1*G >= 0
                                         && 1 + -1*A >= 0
                                         && -1 + A >= 0
                                         && A >= 1]
        f24(A,C,G) -> f31(1,C,G)        [-1*G >= 0
                                         && A + -1*G >= 0
                                         && -1*A + -1*G >= 0
                                         && -1*A >= 0
                                         && A >= 0
                                         && 0 >= A
                                         && K >= 1000 + C]
        f24(A,C,G) -> f31(A,C,G)        [-1*G >= 0
                                         && A + -1*G >= 0
                                         && -1*A + -1*G >= 0
                                         && -1*A >= 0
                                         && A >= 0
                                         && 0 >= A
                                         && 999 + C >= K]
        f31(A,C,G) -> exitus616(A,C,G)  True
        f31(A,C,G) -> exitus616(A,C,G)  True
        f31(A,C,G) -> exitus616(A,C,G)  True
        f31(A,C,G) -> exitus616(A,C,G)  True
        f31(A,C,G) -> exitus616(A,C,G)  True
      Signature:
        {(exitus616,3);(f0,10);(f18,10);(f24,10);(f31,10)}
      Rule Graph:
        [0->{3},1->{4},2->{4},3->{3,7,8,9,10,11},4->{5,6},5->{3},6->{3}]
  + Applied Processor:
      Decompose Greedy
  + Details:
      We construct a looptree:
        P: [0,1,2,3,4,5,6,7,8,9,10,11]
        |
        `- p:[3] c: []
MAYBE