Termination Proof using AProVE

Term Rewriting System R:
[x]
+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

+'(+(x, y), z) -> +'(x, +(y, z))
+'(+(x, y), z) -> +'(y, z)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, p1) -> +'(p1, p2)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p2, +(p2, p2)) -> +'(p1, p5)
+'(p2, +(p2, +(p2, x))) -> +'(p1, +(p5, x))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p5, p1) -> +'(p1, p5)
+'(p5, +(p1, x)) -> +'(p1, +(p5, x))
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p5, p2) -> +'(p2, p5)
+'(p5, +(p2, x)) -> +'(p2, +(p5, x))
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, p1) -> +'(p1, p10)
+'(p10, +(p1, x)) -> +'(p1, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p10, p2) -> +'(p2, p10)
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, p5) -> +'(p5, p10)
+'(p10, +(p5, x)) -> +'(p5, +(p10, x))
+'(p10, +(p5, x)) -> +'(p10, x)

Furthermore, R contains two SCCs.

     ↳DPs

       →DP Problem 1

         ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, x)) -> +'(p5, +(p10, x))
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p1, +(p10, x))
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p1, +(p5, x))
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, x)) -> +'(p2, +(p5, x))
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p1, +(p5, x))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, x))) -> +'(p1, +(p5, x))

six new Dependency Pairs are created:

+'(p2, +(p2, +(p2, p5))) -> +'(p1, p10)
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, x)) -> +'(p5, +(p10, x))
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, x)) -> +'(p2, +(p5, x))
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p1, +(p5, x))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, x)) -> +'(p1, +(p10, x))
+'(p10, +(p5, x)) -> +'(p10, x)

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, x)) -> +'(p1, +(p5, x))

six new Dependency Pairs are created:

+'(p5, +(p1, p5)) -> +'(p1, p10)
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 4

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, x)) -> +'(p1, +(p10, x))
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p5, +(p2, x)) -> +'(p2, +(p5, x))
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, x)) -> +'(p5, +(p10, x))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, x)) -> +'(p2, +(p5, x))

six new Dependency Pairs are created:

+'(p5, +(p2, p5)) -> +'(p2, p10)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 5

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, x)) -> +'(p5, +(p10, x))
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, x)) -> +'(p1, +(p10, x))
+'(p10, +(p5, x)) -> +'(p10, x)

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, x)) -> +'(p1, +(p10, x))

six new Dependency Pairs are created:

+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 6

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, x)) -> +'(p2, +(p10, x))
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, x)) -> +'(p5, +(p10, x))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, x)) -> +'(p2, +(p10, x))

six new Dependency Pairs are created:

+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 7

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p10, +(p5, x)) -> +'(p5, +(p10, x))
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, x)) -> +'(p5, +(p10, x))

six new Dependency Pairs are created:

+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 8

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))
+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, p2))) -> +'(p1, +(p2, p5))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 9

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, +(p2, x'')))) -> +'(p1, +(p2, +(p5, x'')))

six new Dependency Pairs are created:

+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 10

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, +(p5, x'')))) -> +'(p1, +(p10, x''))

six new Dependency Pairs are created:

+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 11

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, p2)) -> +'(p1, +(p2, p5))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 12

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p5, x'')))

six new Dependency Pairs are created:

+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 13

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, +(p5, x''))) -> +'(p1, +(p10, x''))

six new Dependency Pairs are created:

+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 14

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, p2)) -> +'(p2, +(p2, p5))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 15

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p5, x'')))

six new Dependency Pairs are created:

+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 16

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, +(p5, x''))) -> +'(p2, +(p10, x''))

six new Dependency Pairs are created:

+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 17

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, p2)) -> +'(p1, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 18

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, +(p2, x''))) -> +'(p1, +(p2, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 19

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, p5)) -> +'(p1, +(p5, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 20

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, +(p5, x''))) -> +'(p1, +(p5, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 21

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, p2)) -> +'(p2, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 22

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, +(p2, x''))) -> +'(p2, +(p2, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 23

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, p5)) -> +'(p2, +(p5, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 24

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, +(p5, x''))) -> +'(p2, +(p5, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 25

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, +(p2, p5)))) -> +'(p1, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 26

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, +(p5, p2)))) -> +'(p1, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 27

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p2, +(p2, +(p2, +(p5, p5)))) -> +'(p1, +(p5, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 28

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, +(p2, p5))) -> +'(p1, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 29

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, +(p5, p2))) -> +'(p1, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 30

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p1, +(p5, p5))) -> +'(p1, +(p5, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 31

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, +(p2, p5))) -> +'(p2, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 32

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, +(p5, p2))) -> +'(p2, +(p2, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 33

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p5, +(p2, +(p5, p5))) -> +'(p2, +(p5, p10))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 34

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p1, +(p2, p5))) -> +'(p1, +(p2, +(p5, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 35

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p2, +(p2, p5))) -> +'(p2, +(p2, +(p5, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 36

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p2, +(p5, p1))) -> +'(p2, +(p5, +(p1, p10)))
+'(p10, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p10)))
+'(p10, +(p1, +(p5, p1))) -> +'(p1, +(p5, +(p1, p10)))
+'(p10, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p10)))
+'(p10, +(p5, p1)) -> +'(p5, +(p1, p10))
+'(p10, +(p2, p1)) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p5, p1))) -> +'(p2, +(p1, p10))
+'(p5, +(p2, +(p2, p1))) -> +'(p2, +(p2, +(p1, p5)))
+'(p5, +(p1, +(p5, p1))) -> +'(p1, +(p1, p10))
+'(p5, +(p1, +(p2, p1))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, +(p5, p1)))) -> +'(p1, +(p1, p10))
+'(p2, +(p2, +(p2, +(p2, p1)))) -> +'(p1, +(p2, +(p1, p5)))
+'(p2, +(p2, +(p2, p1))) -> +'(p1, +(p1, p5))
+'(p5, +(p2, p1)) -> +'(p2, +(p1, p5))
+'(p5, +(p1, p1)) -> +'(p1, +(p1, p5))
+'(p10, +(p1, p1)) -> +'(p1, +(p1, p10))

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 1

POL(p5) = 0

POL(p2) = 0

POL(p10) = 0

POL(y) = 1

POL(+(x₁, x₂)) = x₂

POL(+'(x₁, x₂)) = x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 37

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p2, +(p5, p2))) -> +'(p2, +(p5, +(p2, p10)))
+'(p10, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p10)))
+'(p10, +(p1, +(p5, p2))) -> +'(p1, +(p5, +(p2, p10)))
+'(p10, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p10)))
+'(p10, +(p5, p2)) -> +'(p5, +(p2, p10))
+'(p5, +(p2, +(p2, p2))) -> +'(p2, +(p2, +(p2, p5)))
+'(p5, +(p1, +(p2, p2))) -> +'(p1, +(p2, +(p2, p5)))
+'(p2, +(p2, +(p2, +(p2, p2)))) -> +'(p1, +(p2, +(p2, p5)))

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 1

POL(p5) = 0

POL(p2) = 1

POL(p10) = 0

POL(y) = 0

POL(+(x₁, x₂)) = x₂

POL(+'(x₁, x₂)) = x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 38

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p2, +(p5, p5))) -> +'(p2, +(p5, +(p5, p10)))
+'(p10, +(p1, +(p5, p5))) -> +'(p1, +(p5, +(p5, p10)))
+'(p10, +(p5, p5)) -> +'(p5, +(p5, p10))

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 1

POL(p5) = 1

POL(p2) = 1

POL(p10) = 0

POL(y) = 0

POL(+(x₁, x₂)) = x₂

POL(+'(x₁, x₂)) = x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 39

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p5, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p5, +(p1, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p10, x'')))
+'(p10, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p10, x'')))
+'(p5, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p10, x')))
+'(p5, +(p2, +(p5, +(p2, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p5, +(p1, x')))) -> +'(p2, +(p1, +(p10, x')))
+'(p5, +(p2, +(p2, +(p5, x')))) -> +'(p2, +(p2, +(p10, x')))
+'(p5, +(p2, +(p2, +(p2, x')))) -> +'(p2, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p2, +(p2, +(p1, x')))) -> +'(p2, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p1, +(p5, +(p5, x')))) -> +'(p1, +(p5, +(p10, x')))
+'(p5, +(p1, +(p5, +(p2, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p5, +(p1, x')))) -> +'(p1, +(p1, +(p10, x')))
+'(p5, +(p1, +(p2, +(p5, x')))) -> +'(p1, +(p2, +(p10, x')))
+'(p5, +(p1, +(p2, +(p2, x')))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p5, +(p1, +(p2, +(p1, x')))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p5, +(p2, +(p1, x''))) -> +'(p2, +(p1, +(p5, x'')))
+'(p2, +(p2, +(p2, +(p5, +(p5, x'))))) -> +'(p1, +(p5, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p2, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p5, +(p1, x'))))) -> +'(p1, +(p1, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p5, x'))))) -> +'(p1, +(p2, +(p10, x')))
+'(p2, +(p2, +(p2, +(p2, +(p2, x'))))) -> +'(p1, +(p2, +(p2, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p2, +(p1, x'))))) -> +'(p1, +(p2, +(p1, +(p5, x'))))
+'(p2, +(p2, +(p2, +(p1, x'')))) -> +'(p1, +(p1, +(p5, x'')))
+'(p5, +(p1, +(p1, x''))) -> +'(p1, +(p1, +(p5, x'')))
+'(p1, +(p2, +(p2, x))) -> +'(p5, x)
+'(p10, +(p2, x)) -> +'(p10, x)
+'(p10, +(p1, x)) -> +'(p10, x)
+'(p5, +(p2, x)) -> +'(p5, x)
+'(p5, +(p1, x)) -> +'(p5, x)
+'(p2, +(p2, +(p2, x))) -> +'(p5, x)
+'(p2, +(p1, x)) -> +'(p2, x)
+'(p1, +(p1, x)) -> +'(p2, x)
+'(p10, +(p2, +(p5, +(p5, x')))) -> +'(p2, +(p5, +(p5, +(p10, x'))))

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 1

POL(p5) = 0

POL(p2) = 1

POL(p10) = 0

POL(y) = 1

POL(+(x₁, x₂)) = x₁ + x₂

POL(+'(x₁, x₂)) = 1 + x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 40

                 ↳Dependency Graph

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p2, +(p1, x)) -> +'(p1, +(p2, x))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Using the Dependency Graph the DP problem was split into 1 DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 41

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))
+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p1, x''))) -> +'(p5, +(p1, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p2))) -> +'(p5, +(p1, +(p2, p10)))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, p5))) -> +'(p5, +(p1, +(p5, p10)))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 42

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, p5))) -> +'(p5, +(p1, +(p5, p10)))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, p2))) -> +'(p5, +(p1, +(p2, p10)))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p2, x''))) -> +'(p5, +(p2, +(p10, x'')))

six new Dependency Pairs are created:

+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p2))) -> +'(p5, +(p2, +(p2, p10)))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))
+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 43

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p2, p2))) -> +'(p5, +(p2, +(p2, p10)))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, p5))) -> +'(p5, +(p1, +(p5, p10)))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, p2))) -> +'(p5, +(p1, +(p2, p10)))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p1, p2))) -> +'(p5, +(p1, +(p2, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 44

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p2, p2))) -> +'(p5, +(p2, +(p2, p10)))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, p5))) -> +'(p5, +(p1, +(p5, p10)))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p1, p5))) -> +'(p5, +(p1, +(p5, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 45

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p2, p2))) -> +'(p5, +(p2, +(p2, p10)))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p2, p2))) -> +'(p5, +(p2, +(p2, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 46

                 ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(p10, +(p5, +(p2, p5))) -> +'(p5, +(p2, +(p5, p10)))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 47

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p5, +(p2, p1))) -> +'(p5, +(p2, +(p1, p10)))
+'(p10, +(p5, +(p1, p1))) -> +'(p5, +(p1, +(p1, p10)))

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 1

POL(p5) = 0

POL(p2) = 0

POL(p10) = 0

POL(y) = 0

POL(+(x₁, x₂)) = x₂

POL(+'(x₁, x₂)) = x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 48

                 ↳Polynomial Ordering

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

The following dependency pairs can be strictly oriented:

+'(p10, +(p5, x)) -> +'(p10, x)
+'(p5, +(p5, x)) -> +'(p10, x)

Additionally, the following usable rules w.r.t. to the implicit AFS can be oriented:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(z) = 0

POL(p1) = 0

POL(p5) = 0

POL(p2) = 0

POL(p10) = 0

POL(y) = 1

POL(+(x₁, x₂)) = 1 + x₁ + x₂

POL(+'(x₁, x₂)) = 1 + x₂

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 3

             ↳Nar

...

               →DP Problem 49

                 ↳Dependency Graph

       →DP Problem 2

         ↳Nar

Dependency Pairs:

+'(p10, +(p5, +(p2, +(p5, x')))) -> +'(p5, +(p2, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p2, +(p1, x')))) -> +'(p5, +(p2, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p5, x')))) -> +'(p5, +(p1, +(p5, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p2, x')))) -> +'(p5, +(p1, +(p2, +(p10, x'))))
+'(p10, +(p5, +(p1, +(p1, x')))) -> +'(p5, +(p1, +(p1, +(p10, x'))))
+'(p10, +(p5, +(p5, x''))) -> +'(p5, +(p5, +(p10, x'')))
+'(p10, +(p5, +(p2, +(p2, x')))) -> +'(p5, +(p2, +(p2, +(p10, x'))))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Narrowing Transformation

Dependency Pair:

+'(+(x, y), z) -> +'(x, +(y, z))

Rules:

+(p1, p1) -> p2
+(p1, +(p2, p2)) -> p5
+(p5, p5) -> p10
+(+(x, y), z) -> +(x, +(y, z))
+(p1, +(p1, x)) -> +(p2, x)
+(p1, +(p2, +(p2, x))) -> +(p5, x)
+(p2, p1) -> +(p1, p2)
+(p2, +(p1, x)) -> +(p1, +(p2, x))
+(p2, +(p2, p2)) -> +(p1, p5)
+(p2, +(p2, +(p2, x))) -> +(p1, +(p5, x))
+(p5, p1) -> +(p1, p5)
+(p5, +(p1, x)) -> +(p1, +(p5, x))
+(p5, p2) -> +(p2, p5)
+(p5, +(p2, x)) -> +(p2, +(p5, x))
+(p5, +(p5, x)) -> +(p10, x)
+(p10, p1) -> +(p1, p10)
+(p10, +(p1, x)) -> +(p1, +(p10, x))
+(p10, p2) -> +(p2, p10)
+(p10, +(p2, x)) -> +(p2, +(p10, x))
+(p10, p5) -> +(p5, p10)
+(p10, +(p5, x)) -> +(p5, +(p10, x))

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

+'(+(x, y), z) -> +'(x, +(y, z))

no new Dependency Pairs are created.
The transformation is resulting in no new DP problems.

Termination of R successfully shown.
Duration:
0:37 minutes

POL(z)	= 0
POL(p1)	= 1
POL(p5)	= 0
POL(p2)	= 0
POL(p10)	= 0
POL(y)	= 1
POL(+(x₁, x₂))	= x₂
POL(+'(x₁, x₂))	= x₂