/export/starexec/sandbox2/solver/bin/starexec_run_Itrs /export/starexec/sandbox2/benchmark/theBenchmark.itrs /export/starexec/sandbox2/output/output_files


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


MAYBE

DP problem for innermost termination.
P =
  max#(cons(I2, l)) -> if#(I2 > max(l), I2, max(l)) 
  max#(cons(I2, l)) -> max#(l) 
  max#(cons(I2, l)) -> max#(l) 
  member#(n, cons(m, B0)) -> member#(n, B0) 
  cond2#(false, I4, B1) -> st#(I4 + 1, B1) 
  cond1#(false, I6, B3) -> cond2#(I6 > max(B3), I6, B3) 
  cond1#(false, I6, B3) -> max#(B3) 
  cond1#(true, I7, B4) -> st#(I7 + 1, B4) 
  stNat#(true, I8, B5) -> cond1#(member(I8, B5), I8, B5) 
  stNat#(true, I8, B5) -> member#(I8, B5) 
  st#(I9, B6) -> stNat#(I9 >= 0, I9, B6) 
  sort#(B7) -> st#(0, B7) 
R = 
  if(false, u, v) -> v 
  if(true, I0, I1) -> I0 
  max(cons(I2, l)) -> if(I2 > max(l), I2, max(l)) 
  max(nil) -> 0 
  member(n, cons(m, B0)) -> n = m || member(n, B0) 
  member(I3, nil) -> false 
  cond2(false, I4, B1) -> st(I4 + 1, B1) 
  cond2(true, I5, B2) -> nil 
  cond1(false, I6, B3) -> cond2(I6 > max(B3), I6, B3) 
  cond1(true, I7, B4) -> cons(I7, st(I7 + 1, B4)) 
  stNat(true, I8, B5) -> cond1(member(I8, B5), I8, B5) 
  st(I9, B6) -> stNat(I9 >= 0, I9, B6) 
  sort(B7) -> st(0, B7) 

This problem is converted using chaining, where edges between chained DPs are removed.

DP problem for innermost termination.
P =
  max#(cons(I2, l)) -> if#(I2 > max(l), I2, max(l)) 
  max#(cons(I2, l)) -> max#(l) 
  max#(cons(I2, l)) -> max#(l) 
  member#(n, cons(m, B0)) -> member#(n, B0) 
  cond2#(false, I4, B1) -> st#(I4 + 1, B1) 
  cond1#(false, I6, B3) -> cond2#(I6 > max(B3), I6, B3) 
  cond1#(false, I6, B3) -> max#(B3) 
  cond1#(true, I7, B4) -> st#(I7 + 1, B4) 
  stNat#(true, I8, B5) -> cond1#(member(I8, B5), I8, B5) 
  stNat#(true, I8, B5) -> member#(I8, B5) 
  st#(I9, B6) -> stNat#(I9 >= 0, I9, B6) 
  sort#(B7) -> st#(0, B7) 
  st#(I9, B6) -> cond1#(member(I9, B6), I9, B6) [I9 >= 0]
  st#(I9, B6) -> member#(I9, B6) [I9 >= 0]
R = 
  if(false, u, v) -> v 
  if(true, I0, I1) -> I0 
  max(cons(I2, l)) -> if(I2 > max(l), I2, max(l)) 
  max(nil) -> 0 
  member(n, cons(m, B0)) -> n = m || member(n, B0) 
  member(I3, nil) -> false 
  cond2(false, I4, B1) -> st(I4 + 1, B1) 
  cond2(true, I5, B2) -> nil 
  cond1(false, I6, B3) -> cond2(I6 > max(B3), I6, B3) 
  cond1(true, I7, B4) -> cons(I7, st(I7 + 1, B4)) 
  stNat(true, I8, B5) -> cond1(member(I8, B5), I8, B5) 
  st(I9, B6) -> stNat(I9 >= 0, I9, B6) 
  sort(B7) -> st(0, B7) 

The dependency graph for this problem is:
  0 -> 
  1 -> 0, 1, 2
  2 -> 0, 1, 2
  3 -> 3
  4 -> 13, 12, 10
  5 -> 4
  6 -> 0, 1, 2
  7 -> 13, 12, 10
  8 -> 5, 6, 7
  9 -> 3
  10 -> 
  11 -> 13, 12, 10
  12 -> 7, 6, 5
  13 -> 3
Where:
  0) max#(cons(I2, l)) -> if#(I2 > max(l), I2, max(l)) 
  1) max#(cons(I2, l)) -> max#(l) 
  2) max#(cons(I2, l)) -> max#(l) 
  3) member#(n, cons(m, B0)) -> member#(n, B0) 
  4) cond2#(false, I4, B1) -> st#(I4 + 1, B1) 
  5) cond1#(false, I6, B3) -> cond2#(I6 > max(B3), I6, B3) 
  6) cond1#(false, I6, B3) -> max#(B3) 
  7) cond1#(true, I7, B4) -> st#(I7 + 1, B4) 
  8) stNat#(true, I8, B5) -> cond1#(member(I8, B5), I8, B5) 
  9) stNat#(true, I8, B5) -> member#(I8, B5) 
  10) st#(I9, B6) -> stNat#(I9 >= 0, I9, B6) 
  11) sort#(B7) -> st#(0, B7) 
  12) st#(I9, B6) -> cond1#(member(I9, B6), I9, B6) [I9 >= 0]
  13) st#(I9, B6) -> member#(I9, B6) [I9 >= 0]

We have the following SCCs.
  { 4, 5, 7, 12 }
  { 1, 2 }
  { 3 }

DP problem for innermost termination.
P =
  member#(n, cons(m, B0)) -> member#(n, B0) 
R = 
  if(false, u, v) -> v 
  if(true, I0, I1) -> I0 
  max(cons(I2, l)) -> if(I2 > max(l), I2, max(l)) 
  max(nil) -> 0 
  member(n, cons(m, B0)) -> n = m || member(n, B0) 
  member(I3, nil) -> false 
  cond2(false, I4, B1) -> st(I4 + 1, B1) 
  cond2(true, I5, B2) -> nil 
  cond1(false, I6, B3) -> cond2(I6 > max(B3), I6, B3) 
  cond1(true, I7, B4) -> cons(I7, st(I7 + 1, B4)) 
  stNat(true, I8, B5) -> cond1(member(I8, B5), I8, B5) 
  st(I9, B6) -> stNat(I9 >= 0, I9, B6) 
  sort(B7) -> st(0, B7) 

We use the subterm criterion with the projection function NU:
  NU[member#(x0,x1)] = x1

This gives the following inequalities:
  cons(m, B0) |> B0

All dependency pairs are strictly oriented, so the entire dependency pair problem may be removed.

DP problem for innermost termination.
P =
  max#(cons(I2, l)) -> max#(l) 
  max#(cons(I2, l)) -> max#(l) 
R = 
  if(false, u, v) -> v 
  if(true, I0, I1) -> I0 
  max(cons(I2, l)) -> if(I2 > max(l), I2, max(l)) 
  max(nil) -> 0 
  member(n, cons(m, B0)) -> n = m || member(n, B0) 
  member(I3, nil) -> false 
  cond2(false, I4, B1) -> st(I4 + 1, B1) 
  cond2(true, I5, B2) -> nil 
  cond1(false, I6, B3) -> cond2(I6 > max(B3), I6, B3) 
  cond1(true, I7, B4) -> cons(I7, st(I7 + 1, B4)) 
  stNat(true, I8, B5) -> cond1(member(I8, B5), I8, B5) 
  st(I9, B6) -> stNat(I9 >= 0, I9, B6) 
  sort(B7) -> st(0, B7) 

We use the subterm criterion with the projection function NU:
  NU[max#(x0)] = x0

This gives the following inequalities:
  cons(I2, l) |> l
  cons(I2, l) |> l

All dependency pairs are strictly oriented, so the entire dependency pair problem may be removed.

DP problem for innermost termination.
P =
  cond2#(false, I4, B1) -> st#(I4 + 1, B1) 
  cond1#(false, I6, B3) -> cond2#(I6 > max(B3), I6, B3) 
  cond1#(true, I7, B4) -> st#(I7 + 1, B4) 
  st#(I9, B6) -> cond1#(member(I9, B6), I9, B6) [I9 >= 0]
R = 
  if(false, u, v) -> v 
  if(true, I0, I1) -> I0 
  max(cons(I2, l)) -> if(I2 > max(l), I2, max(l)) 
  max(nil) -> 0 
  member(n, cons(m, B0)) -> n = m || member(n, B0) 
  member(I3, nil) -> false 
  cond2(false, I4, B1) -> st(I4 + 1, B1) 
  cond2(true, I5, B2) -> nil 
  cond1(false, I6, B3) -> cond2(I6 > max(B3), I6, B3) 
  cond1(true, I7, B4) -> cons(I7, st(I7 + 1, B4)) 
  stNat(true, I8, B5) -> cond1(member(I8, B5), I8, B5) 
  st(I9, B6) -> stNat(I9 >= 0, I9, B6) 
  sort(B7) -> st(0, B7)