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


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


YES

Problem:
 active(app(nil(),YS)) -> mark(YS)
 active(app(cons(X,XS),YS)) -> mark(cons(X,app(XS,YS)))
 active(from(X)) -> mark(cons(X,from(s(X))))
 active(zWadr(nil(),YS)) -> mark(nil())
 active(zWadr(XS,nil())) -> mark(nil())
 active(zWadr(cons(X,XS),cons(Y,YS))) -> mark(cons(app(Y,cons(X,nil())),zWadr(XS,YS)))
 active(prefix(L)) -> mark(cons(nil(),zWadr(L,prefix(L))))
 active(app(X1,X2)) -> app(active(X1),X2)
 active(app(X1,X2)) -> app(X1,active(X2))
 active(cons(X1,X2)) -> cons(active(X1),X2)
 active(from(X)) -> from(active(X))
 active(s(X)) -> s(active(X))
 active(zWadr(X1,X2)) -> zWadr(active(X1),X2)
 active(zWadr(X1,X2)) -> zWadr(X1,active(X2))
 active(prefix(X)) -> prefix(active(X))
 app(mark(X1),X2) -> mark(app(X1,X2))
 app(X1,mark(X2)) -> mark(app(X1,X2))
 cons(mark(X1),X2) -> mark(cons(X1,X2))
 from(mark(X)) -> mark(from(X))
 s(mark(X)) -> mark(s(X))
 zWadr(mark(X1),X2) -> mark(zWadr(X1,X2))
 zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
 prefix(mark(X)) -> mark(prefix(X))
 proper(app(X1,X2)) -> app(proper(X1),proper(X2))
 proper(nil()) -> ok(nil())
 proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
 proper(from(X)) -> from(proper(X))
 proper(s(X)) -> s(proper(X))
 proper(zWadr(X1,X2)) -> zWadr(proper(X1),proper(X2))
 proper(prefix(X)) -> prefix(proper(X))
 app(ok(X1),ok(X2)) -> ok(app(X1,X2))
 cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
 from(ok(X)) -> ok(from(X))
 s(ok(X)) -> ok(s(X))
 zWadr(ok(X1),ok(X2)) -> ok(zWadr(X1,X2))
 prefix(ok(X)) -> ok(prefix(X))
 top(mark(X)) -> top(proper(X))
 top(ok(X)) -> top(active(X))

Proof:
 Matrix Interpretation Processor: dim=2
  
  interpretation:
                         [1 0]  
   [cons](x0, x1) = x0 + [0 0]x1,
   
                  [2 0]     [0]
   [prefix](x0) = [0 1]x0 + [1],
   
                             [0]
   [app](x0, x1) = x0 + x1 + [1],
   
                     [0]
   [mark](x0) = x0 + [1],
   
                [2 0]     [0]
   [from](x0) = [0 3]x0 + [1],
   
              [3 0]  
   [ok](x0) = [0 1]x0,
   
           [0]
   [nil] = [0],
   
                     [2 0]     [2 0]     [0]
   [zWadr](x0, x1) = [0 1]x0 + [0 1]x1 + [2],
   
               [1 1]     [0]
   [top](x0) = [2 0]x0 + [1],
   
                    
   [proper](x0) = x0,
   
             [1 0]  
   [s](x0) = [0 2]x0,
   
                  [3 0]  
   [active](x0) = [0 1]x0
  orientation:
                           [3 0]     [0]         [0]           
   active(app(nil(),YS)) = [0 1]YS + [1] >= YS + [1] = mark(YS)
   
                                [3 0]    [3 0]     [3 0]     [0]        [1 0]     [1 0]     [0]                           
   active(app(cons(X,XS),YS)) = [0 1]X + [0 0]XS + [0 1]YS + [1] >= X + [0 0]XS + [0 0]YS + [1] = mark(cons(X,app(XS,YS)))
   
                     [6 0]    [0]    [3 0]    [0]                           
   active(from(X)) = [0 3]X + [1] >= [0 1]X + [1] = mark(cons(X,from(s(X))))
   
                             [6 0]     [0]    [0]              
   active(zWadr(nil(),YS)) = [0 1]YS + [2] >= [1] = mark(nil())
   
                             [6 0]     [0]    [0]              
   active(zWadr(XS,nil())) = [0 1]XS + [2] >= [1] = mark(nil())
   
                                          [6 0]    [6 0]     [6 0]    [6 0]     [0]        [2 0]         [2 0]     [0]                                                
   active(zWadr(cons(X,XS),cons(Y,YS))) = [0 1]X + [0 0]XS + [0 1]Y + [0 0]YS + [2] >= X + [0 0]XS + Y + [0 0]YS + [2] = mark(cons(app(Y,cons(X,nil())),zWadr(XS,YS)))
   
                       [6 0]    [0]    [6 0]    [0]                                       
   active(prefix(L)) = [0 1]L + [1] >= [0 0]L + [1] = mark(cons(nil(),zWadr(L,prefix(L))))
   
                        [3 0]     [3 0]     [0]    [3 0]          [0]                     
   active(app(X1,X2)) = [0 1]X1 + [0 1]X2 + [1] >= [0 1]X1 + X2 + [1] = app(active(X1),X2)
   
                        [3 0]     [3 0]     [0]         [3 0]     [0]                     
   active(app(X1,X2)) = [0 1]X1 + [0 1]X2 + [1] >= X1 + [0 1]X2 + [1] = app(X1,active(X2))
   
                         [3 0]     [3 0]      [3 0]     [1 0]                        
   active(cons(X1,X2)) = [0 1]X1 + [0 0]X2 >= [0 1]X1 + [0 0]X2 = cons(active(X1),X2)
   
                     [6 0]    [0]    [6 0]    [0]                  
   active(from(X)) = [0 3]X + [1] >= [0 3]X + [1] = from(active(X))
   
                  [3 0]     [3 0]                
   active(s(X)) = [0 2]X >= [0 2]X = s(active(X))
   
                          [6 0]     [6 0]     [0]    [6 0]     [2 0]     [0]                       
   active(zWadr(X1,X2)) = [0 1]X1 + [0 1]X2 + [2] >= [0 1]X1 + [0 1]X2 + [2] = zWadr(active(X1),X2)
   
                          [6 0]     [6 0]     [0]    [2 0]     [6 0]     [0]                       
   active(zWadr(X1,X2)) = [0 1]X1 + [0 1]X2 + [2] >= [0 1]X1 + [0 1]X2 + [2] = zWadr(X1,active(X2))
   
                       [6 0]    [0]    [6 0]    [0]                    
   active(prefix(X)) = [0 1]X + [1] >= [0 1]X + [1] = prefix(active(X))
   
                                [0]              [0]                   
   app(mark(X1),X2) = X1 + X2 + [2] >= X1 + X2 + [2] = mark(app(X1,X2))
   
                                [0]              [0]                   
   app(X1,mark(X2)) = X1 + X2 + [2] >= X1 + X2 + [2] = mark(app(X1,X2))
   
                            [1 0]     [0]         [1 0]     [0]                    
   cons(mark(X1),X2) = X1 + [0 0]X2 + [1] >= X1 + [0 0]X2 + [1] = mark(cons(X1,X2))
   
                   [2 0]    [0]    [2 0]    [0]                
   from(mark(X)) = [0 3]X + [4] >= [0 3]X + [2] = mark(from(X))
   
                [1 0]    [0]    [1 0]    [0]             
   s(mark(X)) = [0 2]X + [2] >= [0 2]X + [1] = mark(s(X))
   
                        [2 0]     [2 0]     [0]    [2 0]     [2 0]     [0]                     
   zWadr(mark(X1),X2) = [0 1]X1 + [0 1]X2 + [3] >= [0 1]X1 + [0 1]X2 + [3] = mark(zWadr(X1,X2))
   
                        [2 0]     [2 0]     [0]    [2 0]     [2 0]     [0]                     
   zWadr(X1,mark(X2)) = [0 1]X1 + [0 1]X2 + [3] >= [0 1]X1 + [0 1]X2 + [3] = mark(zWadr(X1,X2))
   
                     [2 0]    [0]    [2 0]    [0]                  
   prefix(mark(X)) = [0 1]X + [2] >= [0 1]X + [2] = mark(prefix(X))
   
                                  [0]              [0]                             
   proper(app(X1,X2)) = X1 + X2 + [1] >= X1 + X2 + [1] = app(proper(X1),proper(X2))
   
                   [0]    [0]            
   proper(nil()) = [0] >= [0] = ok(nil())
   
                              [1 0]           [1 0]                                
   proper(cons(X1,X2)) = X1 + [0 0]X2 >= X1 + [0 0]X2 = cons(proper(X1),proper(X2))
   
                     [2 0]    [0]    [2 0]    [0]                  
   proper(from(X)) = [0 3]X + [1] >= [0 3]X + [1] = from(proper(X))
   
                  [1 0]     [1 0]                
   proper(s(X)) = [0 2]X >= [0 2]X = s(proper(X))
   
                          [2 0]     [2 0]     [0]    [2 0]     [2 0]     [0]                               
   proper(zWadr(X1,X2)) = [0 1]X1 + [0 1]X2 + [2] >= [0 1]X1 + [0 1]X2 + [2] = zWadr(proper(X1),proper(X2))
   
                       [2 0]    [0]    [2 0]    [0]                    
   proper(prefix(X)) = [0 1]X + [1] >= [0 1]X + [1] = prefix(proper(X))
   
                        [3 0]     [3 0]     [0]    [3 0]     [3 0]     [0]                 
   app(ok(X1),ok(X2)) = [0 1]X1 + [0 1]X2 + [1] >= [0 1]X1 + [0 1]X2 + [1] = ok(app(X1,X2))
   
                         [3 0]     [3 0]      [3 0]     [3 0]                    
   cons(ok(X1),ok(X2)) = [0 1]X1 + [0 0]X2 >= [0 1]X1 + [0 0]X2 = ok(cons(X1,X2))
   
                 [6 0]    [0]    [6 0]    [0]              
   from(ok(X)) = [0 3]X + [1] >= [0 3]X + [1] = ok(from(X))
   
              [3 0]     [3 0]            
   s(ok(X)) = [0 2]X >= [0 2]X = ok(s(X))
   
                          [6 0]     [6 0]     [0]    [6 0]     [6 0]     [0]                   
   zWadr(ok(X1),ok(X2)) = [0 1]X1 + [0 1]X2 + [2] >= [0 1]X1 + [0 1]X2 + [2] = ok(zWadr(X1,X2))
   
                   [6 0]    [0]    [6 0]    [0]                
   prefix(ok(X)) = [0 1]X + [1] >= [0 1]X + [1] = ok(prefix(X))
   
                  [1 1]    [1]    [1 1]    [0]                 
   top(mark(X)) = [2 0]X + [1] >= [2 0]X + [1] = top(proper(X))
   
                [3 1]    [0]    [3 1]    [0]                 
   top(ok(X)) = [6 0]X + [1] >= [6 0]X + [1] = top(active(X))
  problem:
   active(app(nil(),YS)) -> mark(YS)
   active(app(cons(X,XS),YS)) -> mark(cons(X,app(XS,YS)))
   active(from(X)) -> mark(cons(X,from(s(X))))
   active(zWadr(nil(),YS)) -> mark(nil())
   active(zWadr(XS,nil())) -> mark(nil())
   active(zWadr(cons(X,XS),cons(Y,YS))) -> mark(cons(app(Y,cons(X,nil())),zWadr(XS,YS)))
   active(prefix(L)) -> mark(cons(nil(),zWadr(L,prefix(L))))
   active(app(X1,X2)) -> app(active(X1),X2)
   active(app(X1,X2)) -> app(X1,active(X2))
   active(cons(X1,X2)) -> cons(active(X1),X2)
   active(from(X)) -> from(active(X))
   active(s(X)) -> s(active(X))
   active(zWadr(X1,X2)) -> zWadr(active(X1),X2)
   active(zWadr(X1,X2)) -> zWadr(X1,active(X2))
   active(prefix(X)) -> prefix(active(X))
   app(mark(X1),X2) -> mark(app(X1,X2))
   app(X1,mark(X2)) -> mark(app(X1,X2))
   cons(mark(X1),X2) -> mark(cons(X1,X2))
   from(mark(X)) -> mark(from(X))
   s(mark(X)) -> mark(s(X))
   zWadr(mark(X1),X2) -> mark(zWadr(X1,X2))
   zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
   prefix(mark(X)) -> mark(prefix(X))
   proper(app(X1,X2)) -> app(proper(X1),proper(X2))
   proper(nil()) -> ok(nil())
   proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
   proper(from(X)) -> from(proper(X))
   proper(s(X)) -> s(proper(X))
   proper(zWadr(X1,X2)) -> zWadr(proper(X1),proper(X2))
   proper(prefix(X)) -> prefix(proper(X))
   app(ok(X1),ok(X2)) -> ok(app(X1,X2))
   cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
   from(ok(X)) -> ok(from(X))
   s(ok(X)) -> ok(s(X))
   zWadr(ok(X1),ok(X2)) -> ok(zWadr(X1,X2))
   prefix(ok(X)) -> ok(prefix(X))
   top(ok(X)) -> top(active(X))
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [cons](x0, x1) = 3x0 + x1 + 1,
    
    [prefix](x0) = 4x0 + 4,
    
    [app](x0, x1) = 2x0 + x1 + 2,
    
    [mark](x0) = x0,
    
    [from](x0) = x0,
    
    [ok](x0) = 4x0 + 4,
    
    [nil] = 2,
    
    [zWadr](x0, x1) = x0 + 2x1 + 2,
    
    [top](x0) = x0,
    
    [proper](x0) = 7x0 + 2,
    
    [s](x0) = x0,
    
    [active](x0) = 4x0 + 1
   orientation:
    active(app(nil(),YS)) = 4YS + 25 >= YS = mark(YS)
    
    active(app(cons(X,XS),YS)) = 24X + 8XS + 4YS + 17 >= 3X + 2XS + YS + 3 = mark(cons(X,app(XS,YS)))
    
    active(from(X)) = 4X + 1 >= 4X + 1 = mark(cons(X,from(s(X))))
    
    active(zWadr(nil(),YS)) = 8YS + 17 >= 2 = mark(nil())
    
    active(zWadr(XS,nil())) = 4XS + 25 >= 2 = mark(nil())
    
    active(zWadr(cons(X,XS),cons(Y,YS))) = 12X + 4XS + 24Y + 8YS + 21 >= 9X + XS + 6Y + 2YS + 18 = mark(cons(app(Y,cons(X,nil())),zWadr(XS,YS)))
    
    active(prefix(L)) = 16L + 17 >= 9L + 17 = mark(cons(nil(),zWadr(L,prefix(L))))
    
    active(app(X1,X2)) = 8X1 + 4X2 + 9 >= 8X1 + X2 + 4 = app(active(X1),X2)
    
    active(app(X1,X2)) = 8X1 + 4X2 + 9 >= 2X1 + 4X2 + 3 = app(X1,active(X2))
    
    active(cons(X1,X2)) = 12X1 + 4X2 + 5 >= 12X1 + X2 + 4 = cons(active(X1),X2)
    
    active(from(X)) = 4X + 1 >= 4X + 1 = from(active(X))
    
    active(s(X)) = 4X + 1 >= 4X + 1 = s(active(X))
    
    active(zWadr(X1,X2)) = 4X1 + 8X2 + 9 >= 4X1 + 2X2 + 3 = zWadr(active(X1),X2)
    
    active(zWadr(X1,X2)) = 4X1 + 8X2 + 9 >= X1 + 8X2 + 4 = zWadr(X1,active(X2))
    
    active(prefix(X)) = 16X + 17 >= 16X + 8 = prefix(active(X))
    
    app(mark(X1),X2) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = mark(app(X1,X2))
    
    app(X1,mark(X2)) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = mark(app(X1,X2))
    
    cons(mark(X1),X2) = 3X1 + X2 + 1 >= 3X1 + X2 + 1 = mark(cons(X1,X2))
    
    from(mark(X)) = X >= X = mark(from(X))
    
    s(mark(X)) = X >= X = mark(s(X))
    
    zWadr(mark(X1),X2) = X1 + 2X2 + 2 >= X1 + 2X2 + 2 = mark(zWadr(X1,X2))
    
    zWadr(X1,mark(X2)) = X1 + 2X2 + 2 >= X1 + 2X2 + 2 = mark(zWadr(X1,X2))
    
    prefix(mark(X)) = 4X + 4 >= 4X + 4 = mark(prefix(X))
    
    proper(app(X1,X2)) = 14X1 + 7X2 + 16 >= 14X1 + 7X2 + 8 = app(proper(X1),proper(X2))
    
    proper(nil()) = 16 >= 12 = ok(nil())
    
    proper(cons(X1,X2)) = 21X1 + 7X2 + 9 >= 21X1 + 7X2 + 9 = cons(proper(X1),proper(X2))
    
    proper(from(X)) = 7X + 2 >= 7X + 2 = from(proper(X))
    
    proper(s(X)) = 7X + 2 >= 7X + 2 = s(proper(X))
    
    proper(zWadr(X1,X2)) = 7X1 + 14X2 + 16 >= 7X1 + 14X2 + 8 = zWadr(proper(X1),proper(X2))
    
    proper(prefix(X)) = 28X + 30 >= 28X + 12 = prefix(proper(X))
    
    app(ok(X1),ok(X2)) = 8X1 + 4X2 + 14 >= 8X1 + 4X2 + 12 = ok(app(X1,X2))
    
    cons(ok(X1),ok(X2)) = 12X1 + 4X2 + 17 >= 12X1 + 4X2 + 8 = ok(cons(X1,X2))
    
    from(ok(X)) = 4X + 4 >= 4X + 4 = ok(from(X))
    
    s(ok(X)) = 4X + 4 >= 4X + 4 = ok(s(X))
    
    zWadr(ok(X1),ok(X2)) = 4X1 + 8X2 + 14 >= 4X1 + 8X2 + 12 = ok(zWadr(X1,X2))
    
    prefix(ok(X)) = 16X + 20 >= 16X + 20 = ok(prefix(X))
    
    top(ok(X)) = 4X + 4 >= 4X + 1 = top(active(X))
   problem:
    active(from(X)) -> mark(cons(X,from(s(X))))
    active(prefix(L)) -> mark(cons(nil(),zWadr(L,prefix(L))))
    active(from(X)) -> from(active(X))
    active(s(X)) -> s(active(X))
    app(mark(X1),X2) -> mark(app(X1,X2))
    app(X1,mark(X2)) -> mark(app(X1,X2))
    cons(mark(X1),X2) -> mark(cons(X1,X2))
    from(mark(X)) -> mark(from(X))
    s(mark(X)) -> mark(s(X))
    zWadr(mark(X1),X2) -> mark(zWadr(X1,X2))
    zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
    prefix(mark(X)) -> mark(prefix(X))
    proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
    proper(from(X)) -> from(proper(X))
    proper(s(X)) -> s(proper(X))
    from(ok(X)) -> ok(from(X))
    s(ok(X)) -> ok(s(X))
    prefix(ok(X)) -> ok(prefix(X))
   Matrix Interpretation Processor: dim=1
    
    interpretation:
     [cons](x0, x1) = x0 + x1 + 1,
     
     [prefix](x0) = 2x0,
     
     [app](x0, x1) = 2x0 + 4x1 + 4,
     
     [mark](x0) = x0 + 2,
     
     [from](x0) = 4x0 + 7,
     
     [ok](x0) = x0,
     
     [nil] = 0,
     
     [zWadr](x0, x1) = 4x0 + x1,
     
     [proper](x0) = 2x0 + 1,
     
     [s](x0) = x0,
     
     [active](x0) = 3x0 + 4
    orientation:
     active(from(X)) = 12X + 25 >= 5X + 10 = mark(cons(X,from(s(X))))
     
     active(prefix(L)) = 6L + 4 >= 6L + 3 = mark(cons(nil(),zWadr(L,prefix(L))))
     
     active(from(X)) = 12X + 25 >= 12X + 23 = from(active(X))
     
     active(s(X)) = 3X + 4 >= 3X + 4 = s(active(X))
     
     app(mark(X1),X2) = 2X1 + 4X2 + 8 >= 2X1 + 4X2 + 6 = mark(app(X1,X2))
     
     app(X1,mark(X2)) = 2X1 + 4X2 + 12 >= 2X1 + 4X2 + 6 = mark(app(X1,X2))
     
     cons(mark(X1),X2) = X1 + X2 + 3 >= X1 + X2 + 3 = mark(cons(X1,X2))
     
     from(mark(X)) = 4X + 15 >= 4X + 9 = mark(from(X))
     
     s(mark(X)) = X + 2 >= X + 2 = mark(s(X))
     
     zWadr(mark(X1),X2) = 4X1 + X2 + 8 >= 4X1 + X2 + 2 = mark(zWadr(X1,X2))
     
     zWadr(X1,mark(X2)) = 4X1 + X2 + 2 >= 4X1 + X2 + 2 = mark(zWadr(X1,X2))
     
     prefix(mark(X)) = 2X + 4 >= 2X + 2 = mark(prefix(X))
     
     proper(cons(X1,X2)) = 2X1 + 2X2 + 3 >= 2X1 + 2X2 + 3 = cons(proper(X1),proper(X2))
     
     proper(from(X)) = 8X + 15 >= 8X + 11 = from(proper(X))
     
     proper(s(X)) = 2X + 1 >= 2X + 1 = s(proper(X))
     
     from(ok(X)) = 4X + 7 >= 4X + 7 = ok(from(X))
     
     s(ok(X)) = X >= X = ok(s(X))
     
     prefix(ok(X)) = 2X >= 2X = ok(prefix(X))
    problem:
     active(s(X)) -> s(active(X))
     cons(mark(X1),X2) -> mark(cons(X1,X2))
     s(mark(X)) -> mark(s(X))
     zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(s(X)) -> s(proper(X))
     from(ok(X)) -> ok(from(X))
     s(ok(X)) -> ok(s(X))
     prefix(ok(X)) -> ok(prefix(X))
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [cons](x0, x1) = 2x0 + 2x1 + 6,
      
      [prefix](x0) = 2x0 + 1,
      
      [mark](x0) = x0,
      
      [from](x0) = 2x0 + 2,
      
      [ok](x0) = 2x0 + 2,
      
      [zWadr](x0, x1) = 2x0 + 2x1 + 2,
      
      [proper](x0) = 2x0 + 2,
      
      [s](x0) = x0,
      
      [active](x0) = 2x0 + 2
     orientation:
      active(s(X)) = 2X + 2 >= 2X + 2 = s(active(X))
      
      cons(mark(X1),X2) = 2X1 + 2X2 + 6 >= 2X1 + 2X2 + 6 = mark(cons(X1,X2))
      
      s(mark(X)) = X >= X = mark(s(X))
      
      zWadr(X1,mark(X2)) = 2X1 + 2X2 + 2 >= 2X1 + 2X2 + 2 = mark(zWadr(X1,X2))
      
      proper(cons(X1,X2)) = 4X1 + 4X2 + 14 >= 4X1 + 4X2 + 14 = cons(proper(X1),proper(X2))
      
      proper(s(X)) = 2X + 2 >= 2X + 2 = s(proper(X))
      
      from(ok(X)) = 4X + 6 >= 4X + 6 = ok(from(X))
      
      s(ok(X)) = 2X + 2 >= 2X + 2 = ok(s(X))
      
      prefix(ok(X)) = 4X + 5 >= 4X + 4 = ok(prefix(X))
     problem:
      active(s(X)) -> s(active(X))
      cons(mark(X1),X2) -> mark(cons(X1,X2))
      s(mark(X)) -> mark(s(X))
      zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
      proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
      proper(s(X)) -> s(proper(X))
      from(ok(X)) -> ok(from(X))
      s(ok(X)) -> ok(s(X))
     Matrix Interpretation Processor: dim=1
      
      interpretation:
       [cons](x0, x1) = 4x0 + 2x1,
       
       [mark](x0) = x0,
       
       [from](x0) = 4x0 + 3,
       
       [ok](x0) = 6x0 + 6,
       
       [zWadr](x0, x1) = 4x0 + x1,
       
       [proper](x0) = x0,
       
       [s](x0) = 2x0,
       
       [active](x0) = 4x0
      orientation:
       active(s(X)) = 8X >= 8X = s(active(X))
       
       cons(mark(X1),X2) = 4X1 + 2X2 >= 4X1 + 2X2 = mark(cons(X1,X2))
       
       s(mark(X)) = 2X >= 2X = mark(s(X))
       
       zWadr(X1,mark(X2)) = 4X1 + X2 >= 4X1 + X2 = mark(zWadr(X1,X2))
       
       proper(cons(X1,X2)) = 4X1 + 2X2 >= 4X1 + 2X2 = cons(proper(X1),proper(X2))
       
       proper(s(X)) = 2X >= 2X = s(proper(X))
       
       from(ok(X)) = 24X + 27 >= 24X + 24 = ok(from(X))
       
       s(ok(X)) = 12X + 12 >= 12X + 6 = ok(s(X))
      problem:
       active(s(X)) -> s(active(X))
       cons(mark(X1),X2) -> mark(cons(X1,X2))
       s(mark(X)) -> mark(s(X))
       zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(s(X)) -> s(proper(X))
      DP Processor:
       DPs:
        active#(s(X)) -> active#(X)
        active#(s(X)) -> s#(active(X))
        cons#(mark(X1),X2) -> cons#(X1,X2)
        s#(mark(X)) -> s#(X)
        zWadr#(X1,mark(X2)) -> zWadr#(X1,X2)
        proper#(cons(X1,X2)) -> proper#(X2)
        proper#(cons(X1,X2)) -> proper#(X1)
        proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
        proper#(s(X)) -> proper#(X)
        proper#(s(X)) -> s#(proper(X))
       TRS:
        active(s(X)) -> s(active(X))
        cons(mark(X1),X2) -> mark(cons(X1,X2))
        s(mark(X)) -> mark(s(X))
        zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
        proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
        proper(s(X)) -> s(proper(X))
       TDG Processor:
        DPs:
         active#(s(X)) -> active#(X)
         active#(s(X)) -> s#(active(X))
         cons#(mark(X1),X2) -> cons#(X1,X2)
         s#(mark(X)) -> s#(X)
         zWadr#(X1,mark(X2)) -> zWadr#(X1,X2)
         proper#(cons(X1,X2)) -> proper#(X2)
         proper#(cons(X1,X2)) -> proper#(X1)
         proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
         proper#(s(X)) -> proper#(X)
         proper#(s(X)) -> s#(proper(X))
        TRS:
         active(s(X)) -> s(active(X))
         cons(mark(X1),X2) -> mark(cons(X1,X2))
         s(mark(X)) -> mark(s(X))
         zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(s(X)) -> s(proper(X))
        graph:
         proper#(s(X)) -> proper#(X) -> proper#(s(X)) -> s#(proper(X))
         proper#(s(X)) -> proper#(X) -> proper#(s(X)) -> proper#(X)
         proper#(s(X)) -> proper#(X) ->
         proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
         proper#(s(X)) -> proper#(X) ->
         proper#(cons(X1,X2)) -> proper#(X1)
         proper#(s(X)) -> proper#(X) ->
         proper#(cons(X1,X2)) -> proper#(X2)
         proper#(s(X)) -> s#(proper(X)) -> s#(mark(X)) -> s#(X)
         proper#(cons(X1,X2)) -> proper#(X2) ->
         proper#(s(X)) -> s#(proper(X))
         proper#(cons(X1,X2)) -> proper#(X2) ->
         proper#(s(X)) -> proper#(X)
         proper#(cons(X1,X2)) -> proper#(X2) ->
         proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
         proper#(cons(X1,X2)) -> proper#(X2) ->
         proper#(cons(X1,X2)) -> proper#(X1)
         proper#(cons(X1,X2)) -> proper#(X2) ->
         proper#(cons(X1,X2)) -> proper#(X2)
         proper#(cons(X1,X2)) -> proper#(X1) ->
         proper#(s(X)) -> s#(proper(X))
         proper#(cons(X1,X2)) -> proper#(X1) ->
         proper#(s(X)) -> proper#(X)
         proper#(cons(X1,X2)) -> proper#(X1) ->
         proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
         proper#(cons(X1,X2)) -> proper#(X1) ->
         proper#(cons(X1,X2)) -> proper#(X1)
         proper#(cons(X1,X2)) -> proper#(X1) ->
         proper#(cons(X1,X2)) -> proper#(X2)
         proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2)) ->
         cons#(mark(X1),X2) -> cons#(X1,X2)
         zWadr#(X1,mark(X2)) -> zWadr#(X1,X2) ->
         zWadr#(X1,mark(X2)) -> zWadr#(X1,X2)
         cons#(mark(X1),X2) -> cons#(X1,X2) ->
         cons#(mark(X1),X2) -> cons#(X1,X2)
         s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X)
         active#(s(X)) -> s#(active(X)) -> s#(mark(X)) -> s#(X)
         active#(s(X)) -> active#(X) -> active#(s(X)) -> s#(active(X))
         active#(s(X)) -> active#(X) -> active#(s(X)) -> active#(X)
        SCC Processor:
         #sccs: 5
         #rules: 7
         #arcs: 23/100
         DPs:
          active#(s(X)) -> active#(X)
         TRS:
          active(s(X)) -> s(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          s(mark(X)) -> mark(s(X))
          zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(s(X)) -> s(proper(X))
         Subterm Criterion Processor:
          simple projection:
           pi(active#) = 0
          problem:
           DPs:
            
           TRS:
            active(s(X)) -> s(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            s(mark(X)) -> mark(s(X))
            zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(s(X)) -> s(proper(X))
          Qed
         
         DPs:
          zWadr#(X1,mark(X2)) -> zWadr#(X1,X2)
         TRS:
          active(s(X)) -> s(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          s(mark(X)) -> mark(s(X))
          zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(s(X)) -> s(proper(X))
         Subterm Criterion Processor:
          simple projection:
           pi(zWadr#) = 1
          problem:
           DPs:
            
           TRS:
            active(s(X)) -> s(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            s(mark(X)) -> mark(s(X))
            zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(s(X)) -> s(proper(X))
          Qed
         
         DPs:
          proper#(s(X)) -> proper#(X)
          proper#(cons(X1,X2)) -> proper#(X2)
          proper#(cons(X1,X2)) -> proper#(X1)
         TRS:
          active(s(X)) -> s(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          s(mark(X)) -> mark(s(X))
          zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(s(X)) -> s(proper(X))
         Subterm Criterion Processor:
          simple projection:
           pi(proper#) = 0
          problem:
           DPs:
            
           TRS:
            active(s(X)) -> s(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            s(mark(X)) -> mark(s(X))
            zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(s(X)) -> s(proper(X))
          Qed
         
         DPs:
          s#(mark(X)) -> s#(X)
         TRS:
          active(s(X)) -> s(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          s(mark(X)) -> mark(s(X))
          zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(s(X)) -> s(proper(X))
         Subterm Criterion Processor:
          simple projection:
           pi(s#) = 0
          problem:
           DPs:
            
           TRS:
            active(s(X)) -> s(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            s(mark(X)) -> mark(s(X))
            zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(s(X)) -> s(proper(X))
          Qed
         
         DPs:
          cons#(mark(X1),X2) -> cons#(X1,X2)
         TRS:
          active(s(X)) -> s(active(X))
          cons(mark(X1),X2) -> mark(cons(X1,X2))
          s(mark(X)) -> mark(s(X))
          zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(s(X)) -> s(proper(X))
         Subterm Criterion Processor:
          simple projection:
           pi(cons#) = 0
          problem:
           DPs:
            
           TRS:
            active(s(X)) -> s(active(X))
            cons(mark(X1),X2) -> mark(cons(X1,X2))
            s(mark(X)) -> mark(s(X))
            zWadr(X1,mark(X2)) -> mark(zWadr(X1,X2))
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(s(X)) -> s(proper(X))
          Qed