/export/starexec/sandbox/solver/bin/starexec_run_ttt2 /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


YES

Problem:
 min(x,0()) -> 0()
 min(0(),y) -> 0()
 min(s(x),s(y)) -> s(min(x,y))
 max(x,0()) -> x
 max(0(),y) -> y
 max(s(x),s(y)) -> s(max(x,y))
 minus(x,0()) -> x
 minus(s(x),s(y)) -> s(minus(x,y))
 gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
 transform(x) -> s(s(x))
 transform(cons(x,y)) -> cons(cons(x,x),x)
 transform(cons(x,y)) -> y
 transform(s(x)) -> s(s(transform(x)))
 cons(x,y) -> y
 cons(x,cons(y,s(z))) -> cons(y,x)
 cons(cons(x,z),s(y)) -> transform(x)

Proof:
 DP Processor:
  DPs:
   min#(s(x),s(y)) -> min#(x,y)
   max#(s(x),s(y)) -> max#(x,y)
   minus#(s(x),s(y)) -> minus#(x,y)
   gcd#(s(x),s(y)) -> min#(x,y)
   gcd#(s(x),s(y)) -> transform#(y)
   gcd#(s(x),s(y)) -> min#(x,transform(y))
   gcd#(s(x),s(y)) -> max#(x,y)
   gcd#(s(x),s(y)) -> minus#(max(x,y),min(x,transform(y)))
   gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
   transform#(cons(x,y)) -> cons#(x,x)
   transform#(cons(x,y)) -> cons#(cons(x,x),x)
   transform#(s(x)) -> transform#(x)
   cons#(x,cons(y,s(z))) -> cons#(y,x)
   cons#(cons(x,z),s(y)) -> transform#(x)
  TRS:
   min(x,0()) -> 0()
   min(0(),y) -> 0()
   min(s(x),s(y)) -> s(min(x,y))
   max(x,0()) -> x
   max(0(),y) -> y
   max(s(x),s(y)) -> s(max(x,y))
   minus(x,0()) -> x
   minus(s(x),s(y)) -> s(minus(x,y))
   gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
   transform(x) -> s(s(x))
   transform(cons(x,y)) -> cons(cons(x,x),x)
   transform(cons(x,y)) -> y
   transform(s(x)) -> s(s(transform(x)))
   cons(x,y) -> y
   cons(x,cons(y,s(z))) -> cons(y,x)
   cons(cons(x,z),s(y)) -> transform(x)
  TDG Processor:
   DPs:
    min#(s(x),s(y)) -> min#(x,y)
    max#(s(x),s(y)) -> max#(x,y)
    minus#(s(x),s(y)) -> minus#(x,y)
    gcd#(s(x),s(y)) -> min#(x,y)
    gcd#(s(x),s(y)) -> transform#(y)
    gcd#(s(x),s(y)) -> min#(x,transform(y))
    gcd#(s(x),s(y)) -> max#(x,y)
    gcd#(s(x),s(y)) -> minus#(max(x,y),min(x,transform(y)))
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
    transform#(cons(x,y)) -> cons#(x,x)
    transform#(cons(x,y)) -> cons#(cons(x,x),x)
    transform#(s(x)) -> transform#(x)
    cons#(x,cons(y,s(z))) -> cons#(y,x)
    cons#(cons(x,z),s(y)) -> transform#(x)
   TRS:
    min(x,0()) -> 0()
    min(0(),y) -> 0()
    min(s(x),s(y)) -> s(min(x,y))
    max(x,0()) -> x
    max(0(),y) -> y
    max(s(x),s(y)) -> s(max(x,y))
    minus(x,0()) -> x
    minus(s(x),s(y)) -> s(minus(x,y))
    gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
    transform(x) -> s(s(x))
    transform(cons(x,y)) -> cons(cons(x,x),x)
    transform(cons(x,y)) -> y
    transform(s(x)) -> s(s(transform(x)))
    cons(x,y) -> y
    cons(x,cons(y,s(z))) -> cons(y,x)
    cons(cons(x,z),s(y)) -> transform(x)
   graph:
    cons#(cons(x,z),s(y)) -> transform#(x) ->
    transform#(s(x)) -> transform#(x)
    cons#(cons(x,z),s(y)) -> transform#(x) ->
    transform#(cons(x,y)) -> cons#(cons(x,x),x)
    cons#(cons(x,z),s(y)) -> transform#(x) ->
    transform#(cons(x,y)) -> cons#(x,x)
    cons#(x,cons(y,s(z))) -> cons#(y,x) ->
    cons#(cons(x,z),s(y)) -> transform#(x)
    cons#(x,cons(y,s(z))) -> cons#(y,x) ->
    cons#(x,cons(y,s(z))) -> cons#(y,x)
    transform#(cons(x,y)) -> cons#(cons(x,x),x) ->
    cons#(cons(x,z),s(y)) -> transform#(x)
    transform#(cons(x,y)) -> cons#(cons(x,x),x) ->
    cons#(x,cons(y,s(z))) -> cons#(y,x)
    transform#(cons(x,y)) -> cons#(x,x) ->
    cons#(cons(x,z),s(y)) -> transform#(x)
    transform#(cons(x,y)) -> cons#(x,x) ->
    cons#(x,cons(y,s(z))) -> cons#(y,x)
    transform#(s(x)) -> transform#(x) ->
    transform#(s(x)) -> transform#(x)
    transform#(s(x)) -> transform#(x) ->
    transform#(cons(x,y)) -> cons#(cons(x,x),x)
    transform#(s(x)) -> transform#(x) ->
    transform#(cons(x,y)) -> cons#(x,x)
    gcd#(s(x),s(y)) -> transform#(y) ->
    transform#(s(x)) -> transform#(x)
    gcd#(s(x),s(y)) -> transform#(y) ->
    transform#(cons(x,y)) -> cons#(cons(x,x),x)
    gcd#(s(x),s(y)) -> transform#(y) ->
    transform#(cons(x,y)) -> cons#(x,x)
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> minus#(max(x,y),min(x,transform(y)))
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> max#(x,y)
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> min#(x,transform(y))
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> transform#(y)
    gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y))) ->
    gcd#(s(x),s(y)) -> min#(x,y)
    gcd#(s(x),s(y)) -> minus#(max(x,y),min(x,transform(y))) ->
    minus#(s(x),s(y)) -> minus#(x,y)
    gcd#(s(x),s(y)) -> max#(x,y) ->
    max#(s(x),s(y)) -> max#(x,y)
    gcd#(s(x),s(y)) -> min#(x,transform(y)) ->
    min#(s(x),s(y)) -> min#(x,y)
    gcd#(s(x),s(y)) -> min#(x,y) -> min#(s(x),s(y)) -> min#(x,y)
    minus#(s(x),s(y)) -> minus#(x,y) ->
    minus#(s(x),s(y)) -> minus#(x,y)
    max#(s(x),s(y)) -> max#(x,y) -> max#(s(x),s(y)) -> max#(x,y)
    min#(s(x),s(y)) -> min#(x,y) -> min#(s(x),s(y)) -> min#(x,y)
   SCC Processor:
    #sccs: 5
    #rules: 9
    #arcs: 28/196
    DPs:
     gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
    TRS:
     min(x,0()) -> 0()
     min(0(),y) -> 0()
     min(s(x),s(y)) -> s(min(x,y))
     max(x,0()) -> x
     max(0(),y) -> y
     max(s(x),s(y)) -> s(max(x,y))
     minus(x,0()) -> x
     minus(s(x),s(y)) -> s(minus(x,y))
     gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     transform(x) -> s(s(x))
     transform(cons(x,y)) -> cons(cons(x,x),x)
     transform(cons(x,y)) -> y
     transform(s(x)) -> s(s(transform(x)))
     cons(x,y) -> y
     cons(x,cons(y,s(z))) -> cons(y,x)
     cons(cons(x,z),s(y)) -> transform(x)
    Usable Rule Processor:
     DPs:
      gcd#(s(x),s(y)) -> gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     TRS:
      min(x,0()) -> 0()
      min(0(),y) -> 0()
      min(s(x),s(y)) -> s(min(x,y))
      transform(x) -> s(s(x))
      transform(cons(x,y)) -> cons(cons(x,x),x)
      transform(cons(x,y)) -> y
      transform(s(x)) -> s(s(transform(x)))
      cons(x,y) -> y
      cons(x,cons(y,s(z))) -> cons(y,x)
      cons(cons(x,z),s(y)) -> transform(x)
      max(x,0()) -> x
      max(0(),y) -> y
      max(s(x),s(y)) -> s(max(x,y))
      minus(x,0()) -> x
      minus(s(x),s(y)) -> s(minus(x,y))
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       min(x,0()) -> 0()
       min(0(),y) -> 0()
       min(s(x),s(y)) -> s(min(x,y))
       max(x,0()) -> x
       max(0(),y) -> y
       max(s(x),s(y)) -> s(max(x,y))
       minus(x,0()) -> x
       minus(s(x),s(y)) -> s(minus(x,y))
      interpretation:
       [minus](x0, x1) = x0,
       
       [min](x0, x1) = 1x0 + 1,
       
       [max](x0, x1) = 2x0 + x1,
       
       [0] = 0,
       
       [cons](x0, x1) = 1x1 + 0,
       
       [gcd#](x0, x1) = 2x0 + x1 + 0,
       
       [transform](x0) = 0,
       
       [s](x0) = 3x0 + 3
      orientation:
       gcd#(s(x),s(y)) = 5x + 3y + 5 >= 4x + 2y + 4 = gcd#(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
       
       min(x,0()) = 1x + 1 >= 0 = 0()
       
       min(0(),y) = 1 >= 0 = 0()
       
       min(s(x),s(y)) = 4x + 4 >= 4x + 4 = s(min(x,y))
       
       transform(x) = 0 >= 6x + 6 = s(s(x))
       
       transform(cons(x,y)) = 0 >= 1x + 0 = cons(cons(x,x),x)
       
       transform(cons(x,y)) = 0 >= y = y
       
       transform(s(x)) = 0 >= 6 = s(s(transform(x)))
       
       cons(x,y) = 1y + 0 >= y = y
       
       cons(x,cons(y,s(z))) = 5z + 5 >= 1x + 0 = cons(y,x)
       
       cons(cons(x,z),s(y)) = 4y + 4 >= 0 = transform(x)
       
       max(x,0()) = 2x + 0 >= x = x
       
       max(0(),y) = y + 2 >= y = y
       
       max(s(x),s(y)) = 5x + 3y + 5 >= 5x + 3y + 3 = s(max(x,y))
       
       minus(x,0()) = x >= x = x
       
       minus(s(x),s(y)) = 3x + 3 >= 3x + 3 = s(minus(x,y))
      problem:
       DPs:
        
       TRS:
        min(x,0()) -> 0()
        min(0(),y) -> 0()
        min(s(x),s(y)) -> s(min(x,y))
        transform(x) -> s(s(x))
        transform(cons(x,y)) -> cons(cons(x,x),x)
        transform(cons(x,y)) -> y
        transform(s(x)) -> s(s(transform(x)))
        cons(x,y) -> y
        cons(x,cons(y,s(z))) -> cons(y,x)
        cons(cons(x,z),s(y)) -> transform(x)
        max(x,0()) -> x
        max(0(),y) -> y
        max(s(x),s(y)) -> s(max(x,y))
        minus(x,0()) -> x
        minus(s(x),s(y)) -> s(minus(x,y))
      Qed
    
    DPs:
     minus#(s(x),s(y)) -> minus#(x,y)
    TRS:
     min(x,0()) -> 0()
     min(0(),y) -> 0()
     min(s(x),s(y)) -> s(min(x,y))
     max(x,0()) -> x
     max(0(),y) -> y
     max(s(x),s(y)) -> s(max(x,y))
     minus(x,0()) -> x
     minus(s(x),s(y)) -> s(minus(x,y))
     gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     transform(x) -> s(s(x))
     transform(cons(x,y)) -> cons(cons(x,x),x)
     transform(cons(x,y)) -> y
     transform(s(x)) -> s(s(transform(x)))
     cons(x,y) -> y
     cons(x,cons(y,s(z))) -> cons(y,x)
     cons(cons(x,z),s(y)) -> transform(x)
    Subterm Criterion Processor:
     simple projection:
      pi(minus#) = 0
     problem:
      DPs:
       
      TRS:
       min(x,0()) -> 0()
       min(0(),y) -> 0()
       min(s(x),s(y)) -> s(min(x,y))
       max(x,0()) -> x
       max(0(),y) -> y
       max(s(x),s(y)) -> s(max(x,y))
       minus(x,0()) -> x
       minus(s(x),s(y)) -> s(minus(x,y))
       gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
       transform(x) -> s(s(x))
       transform(cons(x,y)) -> cons(cons(x,x),x)
       transform(cons(x,y)) -> y
       transform(s(x)) -> s(s(transform(x)))
       cons(x,y) -> y
       cons(x,cons(y,s(z))) -> cons(y,x)
       cons(cons(x,z),s(y)) -> transform(x)
     Qed
    
    DPs:
     max#(s(x),s(y)) -> max#(x,y)
    TRS:
     min(x,0()) -> 0()
     min(0(),y) -> 0()
     min(s(x),s(y)) -> s(min(x,y))
     max(x,0()) -> x
     max(0(),y) -> y
     max(s(x),s(y)) -> s(max(x,y))
     minus(x,0()) -> x
     minus(s(x),s(y)) -> s(minus(x,y))
     gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     transform(x) -> s(s(x))
     transform(cons(x,y)) -> cons(cons(x,x),x)
     transform(cons(x,y)) -> y
     transform(s(x)) -> s(s(transform(x)))
     cons(x,y) -> y
     cons(x,cons(y,s(z))) -> cons(y,x)
     cons(cons(x,z),s(y)) -> transform(x)
    Subterm Criterion Processor:
     simple projection:
      pi(max#) = 0
     problem:
      DPs:
       
      TRS:
       min(x,0()) -> 0()
       min(0(),y) -> 0()
       min(s(x),s(y)) -> s(min(x,y))
       max(x,0()) -> x
       max(0(),y) -> y
       max(s(x),s(y)) -> s(max(x,y))
       minus(x,0()) -> x
       minus(s(x),s(y)) -> s(minus(x,y))
       gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
       transform(x) -> s(s(x))
       transform(cons(x,y)) -> cons(cons(x,x),x)
       transform(cons(x,y)) -> y
       transform(s(x)) -> s(s(transform(x)))
       cons(x,y) -> y
       cons(x,cons(y,s(z))) -> cons(y,x)
       cons(cons(x,z),s(y)) -> transform(x)
     Qed
    
    DPs:
     min#(s(x),s(y)) -> min#(x,y)
    TRS:
     min(x,0()) -> 0()
     min(0(),y) -> 0()
     min(s(x),s(y)) -> s(min(x,y))
     max(x,0()) -> x
     max(0(),y) -> y
     max(s(x),s(y)) -> s(max(x,y))
     minus(x,0()) -> x
     minus(s(x),s(y)) -> s(minus(x,y))
     gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     transform(x) -> s(s(x))
     transform(cons(x,y)) -> cons(cons(x,x),x)
     transform(cons(x,y)) -> y
     transform(s(x)) -> s(s(transform(x)))
     cons(x,y) -> y
     cons(x,cons(y,s(z))) -> cons(y,x)
     cons(cons(x,z),s(y)) -> transform(x)
    Subterm Criterion Processor:
     simple projection:
      pi(min#) = 0
     problem:
      DPs:
       
      TRS:
       min(x,0()) -> 0()
       min(0(),y) -> 0()
       min(s(x),s(y)) -> s(min(x,y))
       max(x,0()) -> x
       max(0(),y) -> y
       max(s(x),s(y)) -> s(max(x,y))
       minus(x,0()) -> x
       minus(s(x),s(y)) -> s(minus(x,y))
       gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
       transform(x) -> s(s(x))
       transform(cons(x,y)) -> cons(cons(x,x),x)
       transform(cons(x,y)) -> y
       transform(s(x)) -> s(s(transform(x)))
       cons(x,y) -> y
       cons(x,cons(y,s(z))) -> cons(y,x)
       cons(cons(x,z),s(y)) -> transform(x)
     Qed
    
    DPs:
     cons#(cons(x,z),s(y)) -> transform#(x)
     transform#(cons(x,y)) -> cons#(x,x)
     cons#(x,cons(y,s(z))) -> cons#(y,x)
     transform#(cons(x,y)) -> cons#(cons(x,x),x)
     transform#(s(x)) -> transform#(x)
    TRS:
     min(x,0()) -> 0()
     min(0(),y) -> 0()
     min(s(x),s(y)) -> s(min(x,y))
     max(x,0()) -> x
     max(0(),y) -> y
     max(s(x),s(y)) -> s(max(x,y))
     minus(x,0()) -> x
     minus(s(x),s(y)) -> s(minus(x,y))
     gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
     transform(x) -> s(s(x))
     transform(cons(x,y)) -> cons(cons(x,x),x)
     transform(cons(x,y)) -> y
     transform(s(x)) -> s(s(transform(x)))
     cons(x,y) -> y
     cons(x,cons(y,s(z))) -> cons(y,x)
     cons(cons(x,z),s(y)) -> transform(x)
    Usable Rule Processor:
     DPs:
      cons#(cons(x,z),s(y)) -> transform#(x)
      transform#(cons(x,y)) -> cons#(x,x)
      cons#(x,cons(y,s(z))) -> cons#(y,x)
      transform#(cons(x,y)) -> cons#(cons(x,x),x)
      transform#(s(x)) -> transform#(x)
     TRS:
      cons(x,y) -> y
      cons(x,cons(y,s(z))) -> cons(y,x)
      cons(cons(x,z),s(y)) -> transform(x)
      transform(x) -> s(s(x))
      transform(cons(x,y)) -> cons(cons(x,x),x)
      transform(cons(x,y)) -> y
      transform(s(x)) -> s(s(transform(x)))
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       cons(x,y) -> y
       cons(x,cons(y,s(z))) -> cons(y,x)
       cons(cons(x,z),s(y)) -> transform(x)
       transform(x) -> s(s(x))
       transform(cons(x,y)) -> cons(cons(x,x),x)
       transform(cons(x,y)) -> y
       transform(s(x)) -> s(s(transform(x)))
      interpretation:
       [cons](x0, x1) = 1x0 + x1,
       
       [transform#](x0) = 2x0,
       
       [cons#](x0, x1) = 2x0 + 1x1,
       
       [transform](x0) = 1x0,
       
       [s](x0) = x0
      orientation:
       cons#(cons(x,z),s(y)) = 3x + 1y + 2z >= 2x = transform#(x)
       
       transform#(cons(x,y)) = 3x + 2y >= 2x = cons#(x,x)
       
       cons#(x,cons(y,s(z))) = 2x + 2y + 1z >= 1x + 2y = cons#(y,x)
       
       transform#(cons(x,y)) = 3x + 2y >= 3x = cons#(cons(x,x),x)
       
       transform#(s(x)) = 2x >= 2x = transform#(x)
       
       cons(x,y) = 1x + y >= y = y
       
       cons(x,cons(y,s(z))) = 1x + 1y + z >= x + 1y = cons(y,x)
       
       cons(cons(x,z),s(y)) = 2x + y + 1z >= 1x = transform(x)
       
       transform(x) = 1x >= x = s(s(x))
       
       transform(cons(x,y)) = 2x + 1y >= 2x = cons(cons(x,x),x)
       
       transform(cons(x,y)) = 2x + 1y >= y = y
       
       transform(s(x)) = 1x >= 1x = s(s(transform(x)))
      problem:
       DPs:
        cons#(x,cons(y,s(z))) -> cons#(y,x)
        transform#(cons(x,y)) -> cons#(cons(x,x),x)
        transform#(s(x)) -> transform#(x)
       TRS:
        cons(x,y) -> y
        cons(x,cons(y,s(z))) -> cons(y,x)
        cons(cons(x,z),s(y)) -> transform(x)
        transform(x) -> s(s(x))
        transform(cons(x,y)) -> cons(cons(x,x),x)
        transform(cons(x,y)) -> y
        transform(s(x)) -> s(s(transform(x)))
      Restore Modifier:
       DPs:
        cons#(x,cons(y,s(z))) -> cons#(y,x)
        transform#(cons(x,y)) -> cons#(cons(x,x),x)
        transform#(s(x)) -> transform#(x)
       TRS:
        min(x,0()) -> 0()
        min(0(),y) -> 0()
        min(s(x),s(y)) -> s(min(x,y))
        max(x,0()) -> x
        max(0(),y) -> y
        max(s(x),s(y)) -> s(max(x,y))
        minus(x,0()) -> x
        minus(s(x),s(y)) -> s(minus(x,y))
        gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
        transform(x) -> s(s(x))
        transform(cons(x,y)) -> cons(cons(x,x),x)
        transform(cons(x,y)) -> y
        transform(s(x)) -> s(s(transform(x)))
        cons(x,y) -> y
        cons(x,cons(y,s(z))) -> cons(y,x)
        cons(cons(x,z),s(y)) -> transform(x)
       SCC Processor:
        #sccs: 2
        #rules: 2
        #arcs: 12/9
        DPs:
         transform#(s(x)) -> transform#(x)
        TRS:
         min(x,0()) -> 0()
         min(0(),y) -> 0()
         min(s(x),s(y)) -> s(min(x,y))
         max(x,0()) -> x
         max(0(),y) -> y
         max(s(x),s(y)) -> s(max(x,y))
         minus(x,0()) -> x
         minus(s(x),s(y)) -> s(minus(x,y))
         gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
         transform(x) -> s(s(x))
         transform(cons(x,y)) -> cons(cons(x,x),x)
         transform(cons(x,y)) -> y
         transform(s(x)) -> s(s(transform(x)))
         cons(x,y) -> y
         cons(x,cons(y,s(z))) -> cons(y,x)
         cons(cons(x,z),s(y)) -> transform(x)
        Size-Change Termination Processor:
         DPs:
          
         TRS:
          min(x,0()) -> 0()
          min(0(),y) -> 0()
          min(s(x),s(y)) -> s(min(x,y))
          max(x,0()) -> x
          max(0(),y) -> y
          max(s(x),s(y)) -> s(max(x,y))
          minus(x,0()) -> x
          minus(s(x),s(y)) -> s(minus(x,y))
          gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
          transform(x) -> s(s(x))
          transform(cons(x,y)) -> cons(cons(x,x),x)
          transform(cons(x,y)) -> y
          transform(s(x)) -> s(s(transform(x)))
          cons(x,y) -> y
          cons(x,cons(y,s(z))) -> cons(y,x)
          cons(cons(x,z),s(y)) -> transform(x)
         The DP: transform#(s(x)) -> transform#(x) has the edges:
           0 >   0
         Qed
        
        DPs:
         cons#(x,cons(y,s(z))) -> cons#(y,x)
        TRS:
         min(x,0()) -> 0()
         min(0(),y) -> 0()
         min(s(x),s(y)) -> s(min(x,y))
         max(x,0()) -> x
         max(0(),y) -> y
         max(s(x),s(y)) -> s(max(x,y))
         minus(x,0()) -> x
         minus(s(x),s(y)) -> s(minus(x,y))
         gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
         transform(x) -> s(s(x))
         transform(cons(x,y)) -> cons(cons(x,x),x)
         transform(cons(x,y)) -> y
         transform(s(x)) -> s(s(transform(x)))
         cons(x,y) -> y
         cons(x,cons(y,s(z))) -> cons(y,x)
         cons(cons(x,z),s(y)) -> transform(x)
        Size-Change Termination Processor:
         DPs:
          
         TRS:
          min(x,0()) -> 0()
          min(0(),y) -> 0()
          min(s(x),s(y)) -> s(min(x,y))
          max(x,0()) -> x
          max(0(),y) -> y
          max(s(x),s(y)) -> s(max(x,y))
          minus(x,0()) -> x
          minus(s(x),s(y)) -> s(minus(x,y))
          gcd(s(x),s(y)) -> gcd(minus(max(x,y),min(x,transform(y))),s(min(x,y)))
          transform(x) -> s(s(x))
          transform(cons(x,y)) -> cons(cons(x,x),x)
          transform(cons(x,y)) -> y
          transform(s(x)) -> s(s(transform(x)))
          cons(x,y) -> y
          cons(x,cons(y,s(z))) -> cons(y,x)
          cons(cons(x,z),s(y)) -> transform(x)
         The DP: cons#(x,cons(y,s(z))) -> cons#(y,x) has the edges:
           0 >=  1
           1 >   0
         Qed