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


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


failure 'Failure("No result of SMT solver - maybe due to some flag of the solver? or the solver was not found in PATH?")' in subprocess 4553
NO

Problem:
 pairNs() -> cons(0(),n__incr(oddNs()))
 oddNs() -> incr(pairNs())
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 take(0(),XS) -> nil()
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 zip(nil(),XS) -> nil()
 zip(X,nil()) -> nil()
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 tail(cons(X,XS)) -> activate(XS)
 repItems(nil()) -> nil()
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 incr(X) -> n__incr(X)
 take(X1,X2) -> n__take(X1,X2)
 zip(X1,X2) -> n__zip(X1,X2)
 cons(X1,X2) -> n__cons(X1,X2)
 repItems(X) -> n__repItems(X)
 activate(n__incr(X)) -> incr(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__repItems(X)) -> repItems(X)
 activate(X) -> X

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [cons](x0, x1) = x0 + x1,
   
   [repItems](x0) = 3x0,
   
   [take](x0, x1) = x0 + x1 + 2,
   
   [0] = 0,
   
   [n__incr](x0) = x0,
   
   [n__repItems](x0) = 3x0,
   
   [n__cons](x0, x1) = x0 + x1,
   
   [incr](x0) = x0,
   
   [n__take](x0, x1) = x0 + x1 + 2,
   
   [pairNs] = 0,
   
   [activate](x0) = x0,
   
   [tail](x0) = x0 + 2,
   
   [pair](x0, x1) = 4x0 + x1,
   
   [zip](x0, x1) = 4x0 + x1,
   
   [nil] = 0,
   
   [n__zip](x0, x1) = 4x0 + x1,
   
   [s](x0) = x0,
   
   [oddNs] = 0
  orientation:
   pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
   
   oddNs() = 0 >= 0 = incr(pairNs())
   
   incr(cons(X,XS)) = X + XS >= X + XS = cons(s(X),n__incr(activate(XS)))
   
   take(0(),XS) = XS + 2 >= 0 = nil()
   
   take(s(N),cons(X,XS)) = N + X + XS + 2 >= N + X + XS + 2 = cons(X,n__take(N,activate(XS)))
   
   zip(nil(),XS) = XS >= 0 = nil()
   
   zip(X,nil()) = 4X >= 0 = nil()
   
   zip(cons(X,XS),cons(Y,YS)) = 4X + 4XS + Y + YS >= 4X + 4XS + Y + YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
   
   tail(cons(X,XS)) = X + XS + 2 >= XS = activate(XS)
   
   repItems(nil()) = 0 >= 0 = nil()
   
   repItems(cons(X,XS)) = 3X + 3XS >= 2X + 3XS = cons(X,n__cons(X,n__repItems(activate(XS))))
   
   incr(X) = X >= X = n__incr(X)
   
   take(X1,X2) = X1 + X2 + 2 >= X1 + X2 + 2 = n__take(X1,X2)
   
   zip(X1,X2) = 4X1 + X2 >= 4X1 + X2 = n__zip(X1,X2)
   
   cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
   
   repItems(X) = 3X >= 3X = n__repItems(X)
   
   activate(n__incr(X)) = X >= X = incr(X)
   
   activate(n__take(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = take(X1,X2)
   
   activate(n__zip(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2)
   
   activate(n__cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2)
   
   activate(n__repItems(X)) = 3X >= 3X = repItems(X)
   
   activate(X) = X >= X = X
  problem:
   pairNs() -> cons(0(),n__incr(oddNs()))
   oddNs() -> incr(pairNs())
   incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
   take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
   zip(nil(),XS) -> nil()
   zip(X,nil()) -> nil()
   zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
   repItems(nil()) -> nil()
   repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
   incr(X) -> n__incr(X)
   take(X1,X2) -> n__take(X1,X2)
   zip(X1,X2) -> n__zip(X1,X2)
   cons(X1,X2) -> n__cons(X1,X2)
   repItems(X) -> n__repItems(X)
   activate(n__incr(X)) -> incr(X)
   activate(n__take(X1,X2)) -> take(X1,X2)
   activate(n__zip(X1,X2)) -> zip(X1,X2)
   activate(n__cons(X1,X2)) -> cons(X1,X2)
   activate(n__repItems(X)) -> repItems(X)
   activate(X) -> X
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [cons](x0, x1) = 2x0 + 4x1,
    
    [repItems](x0) = 4x0,
    
    [take](x0, x1) = 6x0 + 4x1,
    
    [0] = 0,
    
    [n__incr](x0) = x0,
    
    [n__repItems](x0) = x0,
    
    [n__cons](x0, x1) = x0 + x1,
    
    [incr](x0) = 4x0,
    
    [n__take](x0, x1) = 2x0 + x1,
    
    [pairNs] = 0,
    
    [activate](x0) = 4x0,
    
    [pair](x0, x1) = x0 + 2x1,
    
    [zip](x0, x1) = 4x0 + 4x1,
    
    [nil] = 2,
    
    [n__zip](x0, x1) = x0 + x1,
    
    [s](x0) = 4x0,
    
    [oddNs] = 0
   orientation:
    pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
    
    oddNs() = 0 >= 0 = incr(pairNs())
    
    incr(cons(X,XS)) = 8X + 16XS >= 8X + 16XS = cons(s(X),n__incr(activate(XS)))
    
    take(s(N),cons(X,XS)) = 24N + 8X + 16XS >= 8N + 2X + 16XS = cons(X,n__take(N,activate(XS)))
    
    zip(nil(),XS) = 4XS + 8 >= 2 = nil()
    
    zip(X,nil()) = 4X + 8 >= 2 = nil()
    
    zip(cons(X,XS),cons(Y,YS)) = 8X + 16XS + 8Y + 16YS >= 2X + 16XS + 4Y + 16YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
    
    repItems(nil()) = 8 >= 2 = nil()
    
    repItems(cons(X,XS)) = 8X + 16XS >= 6X + 16XS = cons(X,n__cons(X,n__repItems(activate(XS))))
    
    incr(X) = 4X >= X = n__incr(X)
    
    take(X1,X2) = 6X1 + 4X2 >= 2X1 + X2 = n__take(X1,X2)
    
    zip(X1,X2) = 4X1 + 4X2 >= X1 + X2 = n__zip(X1,X2)
    
    cons(X1,X2) = 2X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
    
    repItems(X) = 4X >= X = n__repItems(X)
    
    activate(n__incr(X)) = 4X >= 4X = incr(X)
    
    activate(n__take(X1,X2)) = 8X1 + 4X2 >= 6X1 + 4X2 = take(X1,X2)
    
    activate(n__zip(X1,X2)) = 4X1 + 4X2 >= 4X1 + 4X2 = zip(X1,X2)
    
    activate(n__cons(X1,X2)) = 4X1 + 4X2 >= 2X1 + 4X2 = cons(X1,X2)
    
    activate(n__repItems(X)) = 4X >= 4X = repItems(X)
    
    activate(X) = 4X >= X = X
   problem:
    pairNs() -> cons(0(),n__incr(oddNs()))
    oddNs() -> incr(pairNs())
    incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
    take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
    zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
    repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
    incr(X) -> n__incr(X)
    take(X1,X2) -> n__take(X1,X2)
    zip(X1,X2) -> n__zip(X1,X2)
    cons(X1,X2) -> n__cons(X1,X2)
    repItems(X) -> n__repItems(X)
    activate(n__incr(X)) -> incr(X)
    activate(n__take(X1,X2)) -> take(X1,X2)
    activate(n__zip(X1,X2)) -> zip(X1,X2)
    activate(n__cons(X1,X2)) -> cons(X1,X2)
    activate(n__repItems(X)) -> repItems(X)
    activate(X) -> X
   Matrix Interpretation Processor: dim=1
    
    interpretation:
     [cons](x0, x1) = x0 + 2x1,
     
     [repItems](x0) = 4x0 + 2,
     
     [take](x0, x1) = x0 + 2x1,
     
     [0] = 0,
     
     [n__incr](x0) = 2x0,
     
     [n__repItems](x0) = 2x0 + 1,
     
     [n__cons](x0, x1) = x0 + x1,
     
     [incr](x0) = 4x0,
     
     [n__take](x0, x1) = x0 + x1,
     
     [pairNs] = 0,
     
     [activate](x0) = 2x0,
     
     [pair](x0, x1) = x0 + 4x1,
     
     [zip](x0, x1) = 4x0 + 4x1,
     
     [n__zip](x0, x1) = 2x0 + 2x1,
     
     [s](x0) = 3x0,
     
     [oddNs] = 0
    orientation:
     pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
     
     oddNs() = 0 >= 0 = incr(pairNs())
     
     incr(cons(X,XS)) = 4X + 8XS >= 3X + 8XS = cons(s(X),n__incr(activate(XS)))
     
     take(s(N),cons(X,XS)) = 3N + 2X + 4XS >= 2N + X + 4XS = cons(X,n__take(N,activate(XS)))
     
     zip(cons(X,XS),cons(Y,YS)) = 4X + 8XS + 4Y + 8YS >= X + 8XS + 4Y + 8YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
     
     repItems(cons(X,XS)) = 4X + 8XS + 2 >= 3X + 8XS + 2 = cons(X,n__cons(X,n__repItems(activate(XS))))
     
     incr(X) = 4X >= 2X = n__incr(X)
     
     take(X1,X2) = X1 + 2X2 >= X1 + X2 = n__take(X1,X2)
     
     zip(X1,X2) = 4X1 + 4X2 >= 2X1 + 2X2 = n__zip(X1,X2)
     
     cons(X1,X2) = X1 + 2X2 >= X1 + X2 = n__cons(X1,X2)
     
     repItems(X) = 4X + 2 >= 2X + 1 = n__repItems(X)
     
     activate(n__incr(X)) = 4X >= 4X = incr(X)
     
     activate(n__take(X1,X2)) = 2X1 + 2X2 >= X1 + 2X2 = take(X1,X2)
     
     activate(n__zip(X1,X2)) = 4X1 + 4X2 >= 4X1 + 4X2 = zip(X1,X2)
     
     activate(n__cons(X1,X2)) = 2X1 + 2X2 >= X1 + 2X2 = cons(X1,X2)
     
     activate(n__repItems(X)) = 4X + 2 >= 4X + 2 = repItems(X)
     
     activate(X) = 2X >= X = X
    problem:
     pairNs() -> cons(0(),n__incr(oddNs()))
     oddNs() -> incr(pairNs())
     incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
     take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
     zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
     repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
     incr(X) -> n__incr(X)
     take(X1,X2) -> n__take(X1,X2)
     zip(X1,X2) -> n__zip(X1,X2)
     cons(X1,X2) -> n__cons(X1,X2)
     activate(n__incr(X)) -> incr(X)
     activate(n__take(X1,X2)) -> take(X1,X2)
     activate(n__zip(X1,X2)) -> zip(X1,X2)
     activate(n__cons(X1,X2)) -> cons(X1,X2)
     activate(n__repItems(X)) -> repItems(X)
     activate(X) -> X
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [cons](x0, x1) = 2x0 + 4x1,
      
      [repItems](x0) = 4x0,
      
      [take](x0, x1) = 2x0 + 4x1 + 4,
      
      [0] = 0,
      
      [n__incr](x0) = x0,
      
      [n__repItems](x0) = x0,
      
      [n__cons](x0, x1) = x0 + x1,
      
      [incr](x0) = 4x0,
      
      [n__take](x0, x1) = x0 + x1 + 1,
      
      [pairNs] = 0,
      
      [activate](x0) = 4x0,
      
      [pair](x0, x1) = x0 + x1,
      
      [zip](x0, x1) = 4x0 + 4x1,
      
      [n__zip](x0, x1) = x0 + x1,
      
      [s](x0) = 4x0,
      
      [oddNs] = 0
     orientation:
      pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
      
      oddNs() = 0 >= 0 = incr(pairNs())
      
      incr(cons(X,XS)) = 8X + 16XS >= 8X + 16XS = cons(s(X),n__incr(activate(XS)))
      
      take(s(N),cons(X,XS)) = 8N + 8X + 16XS + 4 >= 4N + 2X + 16XS + 4 = cons(X,n__take(N,activate(XS)))
      
      zip(cons(X,XS),cons(Y,YS)) = 8X + 16XS + 8Y + 16YS >= 2X + 16XS + 2Y + 16YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
      
      repItems(cons(X,XS)) = 8X + 16XS >= 6X + 16XS = cons(X,n__cons(X,n__repItems(activate(XS))))
      
      incr(X) = 4X >= X = n__incr(X)
      
      take(X1,X2) = 2X1 + 4X2 + 4 >= X1 + X2 + 1 = n__take(X1,X2)
      
      zip(X1,X2) = 4X1 + 4X2 >= X1 + X2 = n__zip(X1,X2)
      
      cons(X1,X2) = 2X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
      
      activate(n__incr(X)) = 4X >= 4X = incr(X)
      
      activate(n__take(X1,X2)) = 4X1 + 4X2 + 4 >= 2X1 + 4X2 + 4 = take(X1,X2)
      
      activate(n__zip(X1,X2)) = 4X1 + 4X2 >= 4X1 + 4X2 = zip(X1,X2)
      
      activate(n__cons(X1,X2)) = 4X1 + 4X2 >= 2X1 + 4X2 = cons(X1,X2)
      
      activate(n__repItems(X)) = 4X >= 4X = repItems(X)
      
      activate(X) = 4X >= X = X
     problem:
      pairNs() -> cons(0(),n__incr(oddNs()))
      oddNs() -> incr(pairNs())
      incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
      take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
      zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
      repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
      incr(X) -> n__incr(X)
      zip(X1,X2) -> n__zip(X1,X2)
      cons(X1,X2) -> n__cons(X1,X2)
      activate(n__incr(X)) -> incr(X)
      activate(n__take(X1,X2)) -> take(X1,X2)
      activate(n__zip(X1,X2)) -> zip(X1,X2)
      activate(n__cons(X1,X2)) -> cons(X1,X2)
      activate(n__repItems(X)) -> repItems(X)
      activate(X) -> X
     Matrix Interpretation Processor: dim=1
      
      interpretation:
       [cons](x0, x1) = 2x0 + 4x1,
       
       [repItems](x0) = 4x0,
       
       [take](x0, x1) = 2x0 + 4x1,
       
       [0] = 0,
       
       [n__incr](x0) = x0,
       
       [n__repItems](x0) = x0,
       
       [n__cons](x0, x1) = x0 + x1,
       
       [incr](x0) = 4x0,
       
       [n__take](x0, x1) = 2x0 + x1,
       
       [pairNs] = 0,
       
       [activate](x0) = 4x0,
       
       [pair](x0, x1) = 4x0 + 2x1,
       
       [zip](x0, x1) = 4x0 + 4x1 + 4,
       
       [n__zip](x0, x1) = x0 + x1 + 1,
       
       [s](x0) = 4x0,
       
       [oddNs] = 0
      orientation:
       pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
       
       oddNs() = 0 >= 0 = incr(pairNs())
       
       incr(cons(X,XS)) = 8X + 16XS >= 8X + 16XS = cons(s(X),n__incr(activate(XS)))
       
       take(s(N),cons(X,XS)) = 8N + 8X + 16XS >= 8N + 2X + 16XS = cons(X,n__take(N,activate(XS)))
       
       zip(cons(X,XS),cons(Y,YS)) = 8X + 16XS + 8Y + 16YS + 4 >= 8X + 16XS + 4Y + 16YS + 4 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
       
       repItems(cons(X,XS)) = 8X + 16XS >= 6X + 16XS = cons(X,n__cons(X,n__repItems(activate(XS))))
       
       incr(X) = 4X >= X = n__incr(X)
       
       zip(X1,X2) = 4X1 + 4X2 + 4 >= X1 + X2 + 1 = n__zip(X1,X2)
       
       cons(X1,X2) = 2X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
       
       activate(n__incr(X)) = 4X >= 4X = incr(X)
       
       activate(n__take(X1,X2)) = 8X1 + 4X2 >= 2X1 + 4X2 = take(X1,X2)
       
       activate(n__zip(X1,X2)) = 4X1 + 4X2 + 4 >= 4X1 + 4X2 + 4 = zip(X1,X2)
       
       activate(n__cons(X1,X2)) = 4X1 + 4X2 >= 2X1 + 4X2 = cons(X1,X2)
       
       activate(n__repItems(X)) = 4X >= 4X = repItems(X)
       
       activate(X) = 4X >= X = X
      problem:
       pairNs() -> cons(0(),n__incr(oddNs()))
       oddNs() -> incr(pairNs())
       incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
       take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
       zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
       repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
       incr(X) -> n__incr(X)
       cons(X1,X2) -> n__cons(X1,X2)
       activate(n__incr(X)) -> incr(X)
       activate(n__take(X1,X2)) -> take(X1,X2)
       activate(n__zip(X1,X2)) -> zip(X1,X2)
       activate(n__cons(X1,X2)) -> cons(X1,X2)
       activate(n__repItems(X)) -> repItems(X)
       activate(X) -> X
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [cons](x0, x1) = 4x0 + x1,
        
        [repItems](x0) = 2x0,
        
        [take](x0, x1) = 2x0 + 2x1,
        
        [0] = 0,
        
        [n__incr](x0) = 2x0,
        
        [n__repItems](x0) = x0,
        
        [n__cons](x0, x1) = 4x0 + x1,
        
        [incr](x0) = 4x0,
        
        [n__take](x0, x1) = x0 + x1,
        
        [pairNs] = 0,
        
        [activate](x0) = 2x0,
        
        [pair](x0, x1) = x0 + x1,
        
        [zip](x0, x1) = 2x0 + 4x1 + 1,
        
        [n__zip](x0, x1) = x0 + 2x1 + 1,
        
        [s](x0) = 4x0,
        
        [oddNs] = 0
       orientation:
        pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
        
        oddNs() = 0 >= 0 = incr(pairNs())
        
        incr(cons(X,XS)) = 16X + 4XS >= 16X + 4XS = cons(s(X),n__incr(activate(XS)))
        
        take(s(N),cons(X,XS)) = 8N + 8X + 2XS >= N + 4X + 2XS = cons(X,n__take(N,activate(XS)))
        
        zip(cons(X,XS),cons(Y,YS)) = 8X + 2XS + 16Y + 4YS + 1 >= 4X + 2XS + 4Y + 4YS + 1 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
        
        repItems(cons(X,XS)) = 8X + 2XS >= 8X + 2XS = cons(X,n__cons(X,n__repItems(activate(XS))))
        
        incr(X) = 4X >= 2X = n__incr(X)
        
        cons(X1,X2) = 4X1 + X2 >= 4X1 + X2 = n__cons(X1,X2)
        
        activate(n__incr(X)) = 4X >= 4X = incr(X)
        
        activate(n__take(X1,X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2)
        
        activate(n__zip(X1,X2)) = 2X1 + 4X2 + 2 >= 2X1 + 4X2 + 1 = zip(X1,X2)
        
        activate(n__cons(X1,X2)) = 8X1 + 2X2 >= 4X1 + X2 = cons(X1,X2)
        
        activate(n__repItems(X)) = 2X >= 2X = repItems(X)
        
        activate(X) = 2X >= X = X
       problem:
        pairNs() -> cons(0(),n__incr(oddNs()))
        oddNs() -> incr(pairNs())
        incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
        take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
        zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
        repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
        incr(X) -> n__incr(X)
        cons(X1,X2) -> n__cons(X1,X2)
        activate(n__incr(X)) -> incr(X)
        activate(n__take(X1,X2)) -> take(X1,X2)
        activate(n__cons(X1,X2)) -> cons(X1,X2)
        activate(n__repItems(X)) -> repItems(X)
        activate(X) -> X
       Matrix Interpretation Processor: dim=1
        
        interpretation:
         [cons](x0, x1) = 2x0 + 4x1,
         
         [repItems](x0) = 4x0,
         
         [take](x0, x1) = 6x0 + 4x1 + 4,
         
         [0] = 0,
         
         [n__incr](x0) = x0,
         
         [n__repItems](x0) = x0,
         
         [n__cons](x0, x1) = x0 + x1,
         
         [incr](x0) = 4x0,
         
         [n__take](x0, x1) = 2x0 + x1 + 1,
         
         [pairNs] = 0,
         
         [activate](x0) = 4x0,
         
         [pair](x0, x1) = 6x0 + 6x1 + 2,
         
         [zip](x0, x1) = 6x0 + 6x1 + 5,
         
         [n__zip](x0, x1) = x0 + x1,
         
         [s](x0) = 3x0,
         
         [oddNs] = 0
        orientation:
         pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
         
         oddNs() = 0 >= 0 = incr(pairNs())
         
         incr(cons(X,XS)) = 8X + 16XS >= 6X + 16XS = cons(s(X),n__incr(activate(XS)))
         
         take(s(N),cons(X,XS)) = 18N + 8X + 16XS + 4 >= 8N + 2X + 16XS + 4 = cons(X,n__take(N,activate(XS)))
         
         zip(cons(X,XS),cons(Y,YS)) = 12X + 24XS + 12Y + 24YS + 5 >= 12X + 16XS + 12Y + 16YS + 4 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
         
         repItems(cons(X,XS)) = 8X + 16XS >= 6X + 16XS = cons(X,n__cons(X,n__repItems(activate(XS))))
         
         incr(X) = 4X >= X = n__incr(X)
         
         cons(X1,X2) = 2X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
         
         activate(n__incr(X)) = 4X >= 4X = incr(X)
         
         activate(n__take(X1,X2)) = 8X1 + 4X2 + 4 >= 6X1 + 4X2 + 4 = take(X1,X2)
         
         activate(n__cons(X1,X2)) = 4X1 + 4X2 >= 2X1 + 4X2 = cons(X1,X2)
         
         activate(n__repItems(X)) = 4X >= 4X = repItems(X)
         
         activate(X) = 4X >= X = X
        problem:
         pairNs() -> cons(0(),n__incr(oddNs()))
         oddNs() -> incr(pairNs())
         incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
         take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
         repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
         incr(X) -> n__incr(X)
         cons(X1,X2) -> n__cons(X1,X2)
         activate(n__incr(X)) -> incr(X)
         activate(n__take(X1,X2)) -> take(X1,X2)
         activate(n__cons(X1,X2)) -> cons(X1,X2)
         activate(n__repItems(X)) -> repItems(X)
         activate(X) -> X
        Matrix Interpretation Processor: dim=1
         
         interpretation:
          [cons](x0, x1) = 4x0 + x1,
          
          [repItems](x0) = 2x0 + 6,
          
          [take](x0, x1) = 2x0 + 2x1,
          
          [0] = 0,
          
          [n__incr](x0) = 2x0,
          
          [n__repItems](x0) = x0 + 4,
          
          [n__cons](x0, x1) = 2x0 + x1,
          
          [incr](x0) = 4x0,
          
          [n__take](x0, x1) = 6x0 + x1,
          
          [pairNs] = 0,
          
          [activate](x0) = 2x0,
          
          [s](x0) = 3x0,
          
          [oddNs] = 0
         orientation:
          pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
          
          oddNs() = 0 >= 0 = incr(pairNs())
          
          incr(cons(X,XS)) = 16X + 4XS >= 12X + 4XS = cons(s(X),n__incr(activate(XS)))
          
          take(s(N),cons(X,XS)) = 6N + 8X + 2XS >= 6N + 4X + 2XS = cons(X,n__take(N,activate(XS)))
          
          repItems(cons(X,XS)) = 8X + 2XS + 6 >= 6X + 2XS + 4 = cons(X,n__cons(X,n__repItems(activate(XS))))
          
          incr(X) = 4X >= 2X = n__incr(X)
          
          cons(X1,X2) = 4X1 + X2 >= 2X1 + X2 = n__cons(X1,X2)
          
          activate(n__incr(X)) = 4X >= 4X = incr(X)
          
          activate(n__take(X1,X2)) = 12X1 + 2X2 >= 2X1 + 2X2 = take(X1,X2)
          
          activate(n__cons(X1,X2)) = 4X1 + 2X2 >= 4X1 + X2 = cons(X1,X2)
          
          activate(n__repItems(X)) = 2X + 8 >= 2X + 6 = repItems(X)
          
          activate(X) = 2X >= X = X
         problem:
          pairNs() -> cons(0(),n__incr(oddNs()))
          oddNs() -> incr(pairNs())
          incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
          take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
          incr(X) -> n__incr(X)
          cons(X1,X2) -> n__cons(X1,X2)
          activate(n__incr(X)) -> incr(X)
          activate(n__take(X1,X2)) -> take(X1,X2)
          activate(n__cons(X1,X2)) -> cons(X1,X2)
          activate(X) -> X
         Matrix Interpretation Processor: dim=1
          
          interpretation:
           [cons](x0, x1) = 4x0 + 2x1,
           
           [take](x0, x1) = 6x0 + 4x1 + 4,
           
           [0] = 0,
           
           [n__incr](x0) = x0,
           
           [n__cons](x0, x1) = 4x0 + 2x1,
           
           [incr](x0) = 4x0,
           
           [n__take](x0, x1) = 2x0 + x1 + 2,
           
           [pairNs] = 0,
           
           [activate](x0) = 4x0,
           
           [s](x0) = 4x0,
           
           [oddNs] = 0
          orientation:
           pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
           
           oddNs() = 0 >= 0 = incr(pairNs())
           
           incr(cons(X,XS)) = 16X + 8XS >= 16X + 8XS = cons(s(X),n__incr(activate(XS)))
           
           take(s(N),cons(X,XS)) = 24N + 16X + 8XS + 4 >= 4N + 4X + 8XS + 4 = cons(X,n__take(N,activate(XS)))
           
           incr(X) = 4X >= X = n__incr(X)
           
           cons(X1,X2) = 4X1 + 2X2 >= 4X1 + 2X2 = n__cons(X1,X2)
           
           activate(n__incr(X)) = 4X >= 4X = incr(X)
           
           activate(n__take(X1,X2)) = 8X1 + 4X2 + 8 >= 6X1 + 4X2 + 4 = take(X1,X2)
           
           activate(n__cons(X1,X2)) = 16X1 + 8X2 >= 4X1 + 2X2 = cons(X1,X2)
           
           activate(X) = 4X >= X = X
          problem:
           pairNs() -> cons(0(),n__incr(oddNs()))
           oddNs() -> incr(pairNs())
           incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
           take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
           incr(X) -> n__incr(X)
           cons(X1,X2) -> n__cons(X1,X2)
           activate(n__incr(X)) -> incr(X)
           activate(n__cons(X1,X2)) -> cons(X1,X2)
           activate(X) -> X
          Matrix Interpretation Processor: dim=1
           
           interpretation:
            [cons](x0, x1) = x0 + x1,
            
            [take](x0, x1) = 2x0 + x1 + 4,
            
            [0] = 0,
            
            [n__incr](x0) = 2x0,
            
            [n__cons](x0, x1) = x0 + x1,
            
            [incr](x0) = 2x0,
            
            [n__take](x0, x1) = 4x0 + x1,
            
            [pairNs] = 0,
            
            [activate](x0) = x0,
            
            [s](x0) = 2x0,
            
            [oddNs] = 0
           orientation:
            pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
            
            oddNs() = 0 >= 0 = incr(pairNs())
            
            incr(cons(X,XS)) = 2X + 2XS >= 2X + 2XS = cons(s(X),n__incr(activate(XS)))
            
            take(s(N),cons(X,XS)) = 4N + X + XS + 4 >= 4N + X + XS = cons(X,n__take(N,activate(XS)))
            
            incr(X) = 2X >= 2X = n__incr(X)
            
            cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
            
            activate(n__incr(X)) = 2X >= 2X = incr(X)
            
            activate(n__cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2)
            
            activate(X) = X >= X = X
           problem:
            pairNs() -> cons(0(),n__incr(oddNs()))
            oddNs() -> incr(pairNs())
            incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
            incr(X) -> n__incr(X)
            cons(X1,X2) -> n__cons(X1,X2)
            activate(n__incr(X)) -> incr(X)
            activate(n__cons(X1,X2)) -> cons(X1,X2)
            activate(X) -> X
           Matrix Interpretation Processor: dim=3
            
            interpretation:
                              [1 0 0]     [1 0 1]     [0]
             [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1]
                              [0 1 0]     [0 0 0]     [1],
             
                   [0]
             [0] = [0]
                   [0],
             
                             [1 0 0]     [0]
             [n__incr](x0) = [0 0 0]x0 + [1]
                             [0 0 0]     [0],
             
                                 [1 0 0]     [1 0 1]     [0]
             [n__cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [0]
                                 [0 1 0]     [0 0 0]     [1],
             
                          [1 0 0]     [0]
             [incr](x0) = [0 0 0]x0 + [1]
                          [0 0 0]     [1],
             
                        [0]
             [pairNs] = [1]
                        [1],
             
                              [1 0 1]  
             [activate](x0) = [0 1 1]x0
                              [0 1 1]  ,
             
                       [1 0 0]  
             [s](x0) = [0 0 0]x0
                       [0 0 0]  ,
             
                       [0]
             [oddNs] = [1]
                       [1]
            orientation:
                        [0]    [0]                             
             pairNs() = [1] >= [1] = cons(0(),n__incr(oddNs()))
                        [1]    [1]                             
             
                       [0]    [0]                 
             oddNs() = [1] >= [1] = incr(pairNs())
                       [1]    [1]                 
             
                                [1 0 0]    [1 0 1]     [0]    [1 0 0]    [1 0 1]     [0]                                   
             incr(cons(X,XS)) = [0 0 0]X + [0 0 0]XS + [1] >= [0 0 0]X + [0 0 0]XS + [1] = cons(s(X),n__incr(activate(XS)))
                                [0 0 0]    [0 0 0]     [1]    [0 0 0]    [0 0 0]     [1]                                   
             
                       [1 0 0]    [0]    [1 0 0]    [0]             
             incr(X) = [0 0 0]X + [1] >= [0 0 0]X + [1] = n__incr(X)
                       [0 0 0]    [1]    [0 0 0]    [0]             
             
                           [1 0 0]     [1 0 1]     [0]    [1 0 0]     [1 0 1]     [0]                 
             cons(X1,X2) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [0] = n__cons(X1,X2)
                           [0 1 0]     [0 0 0]     [1]    [0 1 0]     [0 0 0]     [1]                 
             
                                    [1 0 0]    [0]    [1 0 0]    [0]          
             activate(n__incr(X)) = [0 0 0]X + [1] >= [0 0 0]X + [1] = incr(X)
                                    [0 0 0]    [1]    [0 0 0]    [1]          
             
                                        [1 1 0]     [1 0 1]     [1]    [1 0 0]     [1 0 1]     [0]              
             activate(n__cons(X1,X2)) = [0 1 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = cons(X1,X2)
                                        [0 1 0]     [0 0 0]     [1]    [0 1 0]     [0 0 0]     [1]              
             
                           [1 0 1]          
             activate(X) = [0 1 1]X >= X = X
                           [0 1 1]          
            problem:
             pairNs() -> cons(0(),n__incr(oddNs()))
             oddNs() -> incr(pairNs())
             incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
             incr(X) -> n__incr(X)
             cons(X1,X2) -> n__cons(X1,X2)
             activate(n__incr(X)) -> incr(X)
             activate(X) -> X
            Unfolding Processor:
             loop length: 2
             terms:
              pairNs()
              cons(0(),n__incr(oddNs()))
             context: cons(0(),n__incr(incr([])))
             substitution:
              
             Qed