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


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


MAYBE
* Step 1: Failure MAYBE
  + Considered Problem:
      - Strict TRS:
          U11(X1,X2,X3,active(X4)) -> U11(X1,X2,X3,X4)
          U11(X1,X2,X3,mark(X4)) -> U11(X1,X2,X3,X4)
          U11(X1,X2,active(X3),X4) -> U11(X1,X2,X3,X4)
          U11(X1,X2,mark(X3),X4) -> U11(X1,X2,X3,X4)
          U11(X1,active(X2),X3,X4) -> U11(X1,X2,X3,X4)
          U11(X1,mark(X2),X3,X4) -> U11(X1,X2,X3,X4)
          U11(active(X1),X2,X3,X4) -> U11(X1,X2,X3,X4)
          U11(mark(X1),X2,X3,X4) -> U11(X1,X2,X3,X4)
          U12(X1,active(X2)) -> U12(X1,X2)
          U12(X1,mark(X2)) -> U12(X1,X2)
          U12(active(X1),X2) -> U12(X1,X2)
          U12(mark(X1),X2) -> U12(X1,X2)
          active(U11(tt(),N,X,XS)) -> mark(U12(splitAt(N,XS),X))
          active(U12(pair(YS,ZS),X)) -> mark(pair(cons(X,YS),ZS))
          active(afterNth(N,XS)) -> mark(snd(splitAt(N,XS)))
          active(and(tt(),X)) -> mark(X)
          active(fst(pair(X,Y))) -> mark(X)
          active(head(cons(N,XS))) -> mark(N)
          active(natsFrom(N)) -> mark(cons(N,natsFrom(s(N))))
          active(sel(N,XS)) -> mark(head(afterNth(N,XS)))
          active(snd(pair(X,Y))) -> mark(Y)
          active(splitAt(0(),XS)) -> mark(pair(nil(),XS))
          active(splitAt(s(N),cons(X,XS))) -> mark(U11(tt(),N,X,XS))
          active(tail(cons(N,XS))) -> mark(XS)
          active(take(N,XS)) -> mark(fst(splitAt(N,XS)))
          afterNth(X1,active(X2)) -> afterNth(X1,X2)
          afterNth(X1,mark(X2)) -> afterNth(X1,X2)
          afterNth(active(X1),X2) -> afterNth(X1,X2)
          afterNth(mark(X1),X2) -> afterNth(X1,X2)
          and(X1,active(X2)) -> and(X1,X2)
          and(X1,mark(X2)) -> and(X1,X2)
          and(active(X1),X2) -> and(X1,X2)
          and(mark(X1),X2) -> and(X1,X2)
          cons(X1,active(X2)) -> cons(X1,X2)
          cons(X1,mark(X2)) -> cons(X1,X2)
          cons(active(X1),X2) -> cons(X1,X2)
          cons(mark(X1),X2) -> cons(X1,X2)
          fst(active(X)) -> fst(X)
          fst(mark(X)) -> fst(X)
          head(active(X)) -> head(X)
          head(mark(X)) -> head(X)
          mark(0()) -> active(0())
          mark(U11(X1,X2,X3,X4)) -> active(U11(mark(X1),X2,X3,X4))
          mark(U12(X1,X2)) -> active(U12(mark(X1),X2))
          mark(afterNth(X1,X2)) -> active(afterNth(mark(X1),mark(X2)))
          mark(and(X1,X2)) -> active(and(mark(X1),X2))
          mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
          mark(fst(X)) -> active(fst(mark(X)))
          mark(head(X)) -> active(head(mark(X)))
          mark(natsFrom(X)) -> active(natsFrom(mark(X)))
          mark(nil()) -> active(nil())
          mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
          mark(s(X)) -> active(s(mark(X)))
          mark(sel(X1,X2)) -> active(sel(mark(X1),mark(X2)))
          mark(snd(X)) -> active(snd(mark(X)))
          mark(splitAt(X1,X2)) -> active(splitAt(mark(X1),mark(X2)))
          mark(tail(X)) -> active(tail(mark(X)))
          mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
          mark(tt()) -> active(tt())
          natsFrom(active(X)) -> natsFrom(X)
          natsFrom(mark(X)) -> natsFrom(X)
          pair(X1,active(X2)) -> pair(X1,X2)
          pair(X1,mark(X2)) -> pair(X1,X2)
          pair(active(X1),X2) -> pair(X1,X2)
          pair(mark(X1),X2) -> pair(X1,X2)
          s(active(X)) -> s(X)
          s(mark(X)) -> s(X)
          sel(X1,active(X2)) -> sel(X1,X2)
          sel(X1,mark(X2)) -> sel(X1,X2)
          sel(active(X1),X2) -> sel(X1,X2)
          sel(mark(X1),X2) -> sel(X1,X2)
          snd(active(X)) -> snd(X)
          snd(mark(X)) -> snd(X)
          splitAt(X1,active(X2)) -> splitAt(X1,X2)
          splitAt(X1,mark(X2)) -> splitAt(X1,X2)
          splitAt(active(X1),X2) -> splitAt(X1,X2)
          splitAt(mark(X1),X2) -> splitAt(X1,X2)
          tail(active(X)) -> tail(X)
          tail(mark(X)) -> tail(X)
          take(X1,active(X2)) -> take(X1,X2)
          take(X1,mark(X2)) -> take(X1,X2)
          take(active(X1),X2) -> take(X1,X2)
          take(mark(X1),X2) -> take(X1,X2)
      - Signature:
          {U11/4,U12/2,active/1,afterNth/2,and/2,cons/2,fst/1,head/1,mark/1,natsFrom/1,pair/2,s/1,sel/2,snd/1
          ,splitAt/2,tail/1,take/2} / {0/0,nil/0,tt/0}
      - Obligation:
          innermost derivational complexity wrt. signature {0,U11,U12,active,afterNth,and,cons,fst,head,mark,natsFrom
          ,nil,pair,s,sel,snd,splitAt,tail,take,tt}
  + Applied Processor:
      DecomposeCP {onSelectionCP_ = any strict-rules, withBoundCP_ = RelativeComp, withCP_ = NaturalMI {miDimension = 4, miDegree = 4, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Nothing}}
  + Details:
      The processor is not applicable. The reason is some rule is duplicating.
MAYBE