*** 1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,0()) -> 0()
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,0()) -> 0()
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,0()) -> 0()
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
        f6(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules, greedy = NoGreedy}
    Proof:
      We apply a matrix interpretation of kind constructor based matrix interpretation:
      The following argument positions are considered usable:
        none
      
      Following symbols are considered usable:
        {f0,f1,f2,f3,f4,f5,f6}
      TcT has computed the following interpretation:
         p(0) = [0]
         p(S) = [0]
        p(f0) = [4]
        p(f1) = [4]
        p(f2) = [4]
        p(f3) = [4]
        p(f4) = [4]
        p(f5) = [4]
        p(f6) = [4]
      
      Following rules are strictly oriented:
           f0(x1,0(),x3,x4,x5) = [4]
                               > [0]
                               = 0()
      
         f0(x1,S(x),x3,0(),x5) = [4]
                               > [0]
                               = 0()
      
           f1(x1,x2,x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
           f2(x1,x2,0(),x4,x5) = [4]
                               > [0]
                               = 0()
      
        f2(x1,x2,S(x),0(),0()) = [4]
                               > [0]
                               = 0()
      
      f2(x1,x2,S(x'),S(x),0()) = [4]
                               > [0]
                               = 0()
      
           f3(x1,x2,x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
           f4(0(),x2,x3,x4,x5) = [4]
                               > [0]
                               = 0()
      
        f4(S(x),0(),x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
      f4(S(x'),S(x),x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
           f5(x1,x2,x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
           f6(x1,x2,x3,x4,0()) = [4]
                               > [0]
                               = 0()
      
      
      Following rules are (at-least) weakly oriented:
          f0(x1,S(x'),x3,S(x),x5) =  [4]                     
                                  >= [4]                     
                                  =  f1(x',S(x'),x,S(x),S(x))
      
             f1(x1,x2,x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f2(x2,x1,x3,x4,x)       
      
         f2(x1,x2,S(x'),0(),S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f3(x1,x2,x',0(),x)      
      
      f2(x1,x2,S(x''),S(x'),S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f5(x1,x2,S(x''),x',x)   
      
             f3(x1,x2,x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f4(x1,x2,x4,x3,x)       
      
         f4(S(x'),0(),x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f3(x',0(),x3,x4,x)      
      
      f4(S(x''),S(x'),x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f2(S(x''),x',x3,x4,x)   
      
             f5(x1,x2,x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f6(x2,x1,x3,x4,x)       
      
             f6(x1,x2,x3,x4,S(x)) =  [4]                     
                                  >= [4]                     
                                  =  f0(x1,x2,x4,x3,x)       
      
*** 1.1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f1(x1,x2,x3,x4,0()) -> 0()
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f3(x1,x2,x3,x4,0()) -> 0()
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f5(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,0()) -> 0()
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    Proof:
      The weightgap principle applies using the following nonconstant growth matrix-interpretation:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          none
        
        Following symbols are considered usable:
          {}
        TcT has computed the following interpretation:
           p(0) = [2]         
           p(S) = [0]         
          p(f0) = [2]         
          p(f1) = [1] x5 + [0]
          p(f2) = [2]         
          p(f3) = [2]         
          p(f4) = [3]         
          p(f5) = [2] x3 + [2]
          p(f6) = [2]         
        
        Following rules are strictly oriented:
            f0(x1,S(x'),x3,S(x),x5) = [2]                     
                                    > [0]                     
                                    = f1(x',S(x'),x,S(x),S(x))
        
           f4(S(x'),0(),x3,x4,S(x)) = [3]                     
                                    > [2]                     
                                    = f3(x',0(),x3,x4,x)      
        
        f4(S(x''),S(x'),x3,x4,S(x)) = [3]                     
                                    > [2]                     
                                    = f2(S(x''),x',x3,x4,x)   
        
        
        Following rules are (at-least) weakly oriented:
                f0(x1,0(),x3,x4,x5) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
              f0(x1,S(x),x3,0(),x5) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
                f1(x1,x2,x3,x4,0()) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
               f1(x1,x2,x3,x4,S(x)) =  [0]                  
                                    >= [2]                  
                                    =  f2(x2,x1,x3,x4,x)    
        
                f2(x1,x2,0(),x4,x5) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
             f2(x1,x2,S(x),0(),0()) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
           f2(x1,x2,S(x'),0(),S(x)) =  [2]                  
                                    >= [2]                  
                                    =  f3(x1,x2,x',0(),x)   
        
           f2(x1,x2,S(x'),S(x),0()) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
        f2(x1,x2,S(x''),S(x'),S(x)) =  [2]                  
                                    >= [2]                  
                                    =  f5(x1,x2,S(x''),x',x)
        
                f3(x1,x2,x3,x4,0()) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
               f3(x1,x2,x3,x4,S(x)) =  [2]                  
                                    >= [3]                  
                                    =  f4(x1,x2,x4,x3,x)    
        
                f4(0(),x2,x3,x4,x5) =  [3]                  
                                    >= [2]                  
                                    =  0()                  
        
             f4(S(x),0(),x3,x4,0()) =  [3]                  
                                    >= [2]                  
                                    =  0()                  
        
           f4(S(x'),S(x),x3,x4,0()) =  [3]                  
                                    >= [2]                  
                                    =  0()                  
        
                f5(x1,x2,x3,x4,0()) =  [2] x3 + [2]         
                                    >= [2]                  
                                    =  0()                  
        
               f5(x1,x2,x3,x4,S(x)) =  [2] x3 + [2]         
                                    >= [2]                  
                                    =  f6(x2,x1,x3,x4,x)    
        
                f6(x1,x2,x3,x4,0()) =  [2]                  
                                    >= [2]                  
                                    =  0()                  
        
               f6(x1,x2,x3,x4,S(x)) =  [2]                  
                                    >= [2]                  
                                    =  f0(x1,x2,x4,x3,x)    
        
      Further, it can be verified that all rules not oriented are covered by the weightgap condition.
*** 1.1.1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,0()) -> 0()
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f3(x1,x2,x3,x4,0()) -> 0()
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,0()) -> 0()
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules, greedy = NoGreedy}
    Proof:
      We apply a matrix interpretation of kind constructor based matrix interpretation:
      The following argument positions are considered usable:
        none
      
      Following symbols are considered usable:
        {f0,f1,f2,f3,f4,f5,f6}
      TcT has computed the following interpretation:
         p(0) = [0]                  
         p(S) = [1] x1 + [4]         
        p(f0) = [2] x4 + [0]         
        p(f1) = [2] x3 + [0]         
        p(f2) = [2] x3 + [0]         
        p(f3) = [2] x3 + [2] x4 + [0]
        p(f4) = [2] x3 + [2] x4 + [0]
        p(f5) = [2] x3 + [0]         
        p(f6) = [2] x3 + [0]         
      
      Following rules are strictly oriented:
      f2(x1,x2,S(x'),0(),S(x)) = [2] x' + [8]      
                               > [2] x' + [0]      
                               = f3(x1,x2,x',0(),x)
      
      
      Following rules are (at-least) weakly oriented:
              f0(x1,0(),x3,x4,x5) =  [2] x4 + [0]            
                                  >= [0]                     
                                  =  0()                     
      
            f0(x1,S(x),x3,0(),x5) =  [0]                     
                                  >= [0]                     
                                  =  0()                     
      
          f0(x1,S(x'),x3,S(x),x5) =  [2] x + [8]             
                                  >= [2] x + [0]             
                                  =  f1(x',S(x'),x,S(x),S(x))
      
              f1(x1,x2,x3,x4,0()) =  [2] x3 + [0]            
                                  >= [0]                     
                                  =  0()                     
      
             f1(x1,x2,x3,x4,S(x)) =  [2] x3 + [0]            
                                  >= [2] x3 + [0]            
                                  =  f2(x2,x1,x3,x4,x)       
      
              f2(x1,x2,0(),x4,x5) =  [0]                     
                                  >= [0]                     
                                  =  0()                     
      
           f2(x1,x2,S(x),0(),0()) =  [2] x + [8]             
                                  >= [0]                     
                                  =  0()                     
      
         f2(x1,x2,S(x'),S(x),0()) =  [2] x' + [8]            
                                  >= [0]                     
                                  =  0()                     
      
      f2(x1,x2,S(x''),S(x'),S(x)) =  [2] x'' + [8]           
                                  >= [2] x'' + [8]           
                                  =  f5(x1,x2,S(x''),x',x)   
      
              f3(x1,x2,x3,x4,0()) =  [2] x3 + [2] x4 + [0]   
                                  >= [0]                     
                                  =  0()                     
      
             f3(x1,x2,x3,x4,S(x)) =  [2] x3 + [2] x4 + [0]   
                                  >= [2] x3 + [2] x4 + [0]   
                                  =  f4(x1,x2,x4,x3,x)       
      
              f4(0(),x2,x3,x4,x5) =  [2] x3 + [2] x4 + [0]   
                                  >= [0]                     
                                  =  0()                     
      
           f4(S(x),0(),x3,x4,0()) =  [2] x3 + [2] x4 + [0]   
                                  >= [0]                     
                                  =  0()                     
      
         f4(S(x'),0(),x3,x4,S(x)) =  [2] x3 + [2] x4 + [0]   
                                  >= [2] x3 + [2] x4 + [0]   
                                  =  f3(x',0(),x3,x4,x)      
      
         f4(S(x'),S(x),x3,x4,0()) =  [2] x3 + [2] x4 + [0]   
                                  >= [0]                     
                                  =  0()                     
      
      f4(S(x''),S(x'),x3,x4,S(x)) =  [2] x3 + [2] x4 + [0]   
                                  >= [2] x3 + [0]            
                                  =  f2(S(x''),x',x3,x4,x)   
      
              f5(x1,x2,x3,x4,0()) =  [2] x3 + [0]            
                                  >= [0]                     
                                  =  0()                     
      
             f5(x1,x2,x3,x4,S(x)) =  [2] x3 + [0]            
                                  >= [2] x3 + [0]            
                                  =  f6(x2,x1,x3,x4,x)       
      
              f6(x1,x2,x3,x4,0()) =  [2] x3 + [0]            
                                  >= [0]                     
                                  =  0()                     
      
             f6(x1,x2,x3,x4,S(x)) =  [2] x3 + [0]            
                                  >= [2] x3 + [0]            
                                  =  f0(x1,x2,x4,x3,x)       
      
*** 1.1.1.1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,0()) -> 0()
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f3(x1,x2,x3,x4,0()) -> 0()
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,0()) -> 0()
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    Proof:
      The weightgap principle applies using the following nonconstant growth matrix-interpretation:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          none
        
        Following symbols are considered usable:
          {}
        TcT has computed the following interpretation:
           p(0) = [0]
           p(S) = [0]
          p(f0) = [4]
          p(f1) = [0]
          p(f2) = [7]
          p(f3) = [5]
          p(f4) = [7]
          p(f5) = [0]
          p(f6) = [5]
        
        Following rules are strictly oriented:
        f2(x1,x2,S(x''),S(x'),S(x)) = [7]                  
                                    > [0]                  
                                    = f5(x1,x2,S(x''),x',x)
        
               f6(x1,x2,x3,x4,S(x)) = [5]                  
                                    > [4]                  
                                    = f0(x1,x2,x4,x3,x)    
        
        
        Following rules are (at-least) weakly oriented:
                f0(x1,0(),x3,x4,x5) =  [4]                     
                                    >= [0]                     
                                    =  0()                     
        
              f0(x1,S(x),x3,0(),x5) =  [4]                     
                                    >= [0]                     
                                    =  0()                     
        
            f0(x1,S(x'),x3,S(x),x5) =  [4]                     
                                    >= [0]                     
                                    =  f1(x',S(x'),x,S(x),S(x))
        
                f1(x1,x2,x3,x4,0()) =  [0]                     
                                    >= [0]                     
                                    =  0()                     
        
               f1(x1,x2,x3,x4,S(x)) =  [0]                     
                                    >= [7]                     
                                    =  f2(x2,x1,x3,x4,x)       
        
                f2(x1,x2,0(),x4,x5) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
             f2(x1,x2,S(x),0(),0()) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
           f2(x1,x2,S(x'),0(),S(x)) =  [7]                     
                                    >= [5]                     
                                    =  f3(x1,x2,x',0(),x)      
        
           f2(x1,x2,S(x'),S(x),0()) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
                f3(x1,x2,x3,x4,0()) =  [5]                     
                                    >= [0]                     
                                    =  0()                     
        
               f3(x1,x2,x3,x4,S(x)) =  [5]                     
                                    >= [7]                     
                                    =  f4(x1,x2,x4,x3,x)       
        
                f4(0(),x2,x3,x4,x5) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
             f4(S(x),0(),x3,x4,0()) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
           f4(S(x'),0(),x3,x4,S(x)) =  [7]                     
                                    >= [5]                     
                                    =  f3(x',0(),x3,x4,x)      
        
           f4(S(x'),S(x),x3,x4,0()) =  [7]                     
                                    >= [0]                     
                                    =  0()                     
        
        f4(S(x''),S(x'),x3,x4,S(x)) =  [7]                     
                                    >= [7]                     
                                    =  f2(S(x''),x',x3,x4,x)   
        
                f5(x1,x2,x3,x4,0()) =  [0]                     
                                    >= [0]                     
                                    =  0()                     
        
               f5(x1,x2,x3,x4,S(x)) =  [0]                     
                                    >= [5]                     
                                    =  f6(x2,x1,x3,x4,x)       
        
                f6(x1,x2,x3,x4,0()) =  [5]                     
                                    >= [0]                     
                                    =  0()                     
        
      Further, it can be verified that all rules not oriented are covered by the weightgap condition.
*** 1.1.1.1.1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,0()) -> 0()
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,0()) -> 0()
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules, greedy = NoGreedy}
    Proof:
      We apply a matrix interpretation of kind constructor based matrix interpretation:
      The following argument positions are considered usable:
        none
      
      Following symbols are considered usable:
        {f0,f1,f2,f3,f4,f5,f6}
      TcT has computed the following interpretation:
         p(0) = [2]                           
         p(S) = [1] x1 + [4]                  
        p(f0) = [1] x2 + [2] x4 + [1]         
        p(f1) = [1] x2 + [2] x3 + [4]         
        p(f2) = [1] x1 + [2] x3 + [3]         
        p(f3) = [1] x1 + [2] x3 + [2] x4 + [7]
        p(f4) = [1] x1 + [2] x3 + [2] x4 + [4]
        p(f5) = [1] x1 + [2] x3 + [3]         
        p(f6) = [1] x2 + [2] x3 + [2]         
      
      Following rules are strictly oriented:
      f1(x1,x2,x3,x4,S(x)) = [1] x2 + [2] x3 + [4]         
                           > [1] x2 + [2] x3 + [3]         
                           = f2(x2,x1,x3,x4,x)             
      
      f3(x1,x2,x3,x4,S(x)) = [1] x1 + [2] x3 + [2] x4 + [7]
                           > [1] x1 + [2] x3 + [2] x4 + [4]
                           = f4(x1,x2,x4,x3,x)             
      
      f5(x1,x2,x3,x4,S(x)) = [1] x1 + [2] x3 + [3]         
                           > [1] x1 + [2] x3 + [2]         
                           = f6(x2,x1,x3,x4,x)             
      
      
      Following rules are (at-least) weakly oriented:
              f0(x1,0(),x3,x4,x5) =  [2] x4 + [3]                   
                                  >= [2]                            
                                  =  0()                            
      
            f0(x1,S(x),x3,0(),x5) =  [1] x + [9]                    
                                  >= [2]                            
                                  =  0()                            
      
          f0(x1,S(x'),x3,S(x),x5) =  [2] x + [1] x' + [13]          
                                  >= [2] x + [1] x' + [8]           
                                  =  f1(x',S(x'),x,S(x),S(x))       
      
              f1(x1,x2,x3,x4,0()) =  [1] x2 + [2] x3 + [4]          
                                  >= [2]                            
                                  =  0()                            
      
              f2(x1,x2,0(),x4,x5) =  [1] x1 + [7]                   
                                  >= [2]                            
                                  =  0()                            
      
           f2(x1,x2,S(x),0(),0()) =  [2] x + [1] x1 + [11]          
                                  >= [2]                            
                                  =  0()                            
      
         f2(x1,x2,S(x'),0(),S(x)) =  [2] x' + [1] x1 + [11]         
                                  >= [2] x' + [1] x1 + [11]         
                                  =  f3(x1,x2,x',0(),x)             
      
         f2(x1,x2,S(x'),S(x),0()) =  [2] x' + [1] x1 + [11]         
                                  >= [2]                            
                                  =  0()                            
      
      f2(x1,x2,S(x''),S(x'),S(x)) =  [2] x'' + [1] x1 + [11]        
                                  >= [2] x'' + [1] x1 + [11]        
                                  =  f5(x1,x2,S(x''),x',x)          
      
              f3(x1,x2,x3,x4,0()) =  [1] x1 + [2] x3 + [2] x4 + [7] 
                                  >= [2]                            
                                  =  0()                            
      
              f4(0(),x2,x3,x4,x5) =  [2] x3 + [2] x4 + [6]          
                                  >= [2]                            
                                  =  0()                            
      
           f4(S(x),0(),x3,x4,0()) =  [1] x + [2] x3 + [2] x4 + [8]  
                                  >= [2]                            
                                  =  0()                            
      
         f4(S(x'),0(),x3,x4,S(x)) =  [1] x' + [2] x3 + [2] x4 + [8] 
                                  >= [1] x' + [2] x3 + [2] x4 + [7] 
                                  =  f3(x',0(),x3,x4,x)             
      
         f4(S(x'),S(x),x3,x4,0()) =  [1] x' + [2] x3 + [2] x4 + [8] 
                                  >= [2]                            
                                  =  0()                            
      
      f4(S(x''),S(x'),x3,x4,S(x)) =  [1] x'' + [2] x3 + [2] x4 + [8]
                                  >= [1] x'' + [2] x3 + [7]         
                                  =  f2(S(x''),x',x3,x4,x)          
      
              f5(x1,x2,x3,x4,0()) =  [1] x1 + [2] x3 + [3]          
                                  >= [2]                            
                                  =  0()                            
      
              f6(x1,x2,x3,x4,0()) =  [1] x2 + [2] x3 + [2]          
                                  >= [2]                            
                                  =  0()                            
      
             f6(x1,x2,x3,x4,S(x)) =  [1] x2 + [2] x3 + [2]          
                                  >= [1] x2 + [2] x3 + [1]          
                                  =  f0(x1,x2,x4,x3,x)              
      
*** 1.1.1.1.1.1 Progress [(O(1),O(1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        
      Weak DP Rules:
        
      Weak TRS Rules:
        f0(x1,0(),x3,x4,x5) -> 0()
        f0(x1,S(x),x3,0(),x5) -> 0()
        f0(x1,S(x'),x3,S(x),x5) -> f1(x',S(x'),x,S(x),S(x))
        f1(x1,x2,x3,x4,0()) -> 0()
        f1(x1,x2,x3,x4,S(x)) -> f2(x2,x1,x3,x4,x)
        f2(x1,x2,0(),x4,x5) -> 0()
        f2(x1,x2,S(x),0(),0()) -> 0()
        f2(x1,x2,S(x'),0(),S(x)) -> f3(x1,x2,x',0(),x)
        f2(x1,x2,S(x'),S(x),0()) -> 0()
        f2(x1,x2,S(x''),S(x'),S(x)) -> f5(x1,x2,S(x''),x',x)
        f3(x1,x2,x3,x4,0()) -> 0()
        f3(x1,x2,x3,x4,S(x)) -> f4(x1,x2,x4,x3,x)
        f4(0(),x2,x3,x4,x5) -> 0()
        f4(S(x),0(),x3,x4,0()) -> 0()
        f4(S(x'),0(),x3,x4,S(x)) -> f3(x',0(),x3,x4,x)
        f4(S(x'),S(x),x3,x4,0()) -> 0()
        f4(S(x''),S(x'),x3,x4,S(x)) -> f2(S(x''),x',x3,x4,x)
        f5(x1,x2,x3,x4,0()) -> 0()
        f5(x1,x2,x3,x4,S(x)) -> f6(x2,x1,x3,x4,x)
        f6(x1,x2,x3,x4,0()) -> 0()
        f6(x1,x2,x3,x4,S(x)) -> f0(x1,x2,x4,x3,x)
      Signature:
        {f0/5,f1/5,f2/5,f3/5,f4/5,f5/5,f6/5} / {0/0,S/1}
      Obligation:
        Innermost
        basic terms: {f0,f1,f2,f3,f4,f5,f6}/{0,S}
    Applied Processor:
      EmptyProcessor
    Proof:
      The problem is already closed. The intended complexity is O(1).