WORST_CASE(?,O(n^1))
* Step 1: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            checkF(queue(cons(x,xs),r)) -> queue(cons(x,xs),r)
            checkF(queue(nil(),r)) -> queue(rev(r),nil())
            empty() -> queue(nil(),nil())
            enq(0()) -> empty()
            enq(s(n)) -> snoc(enq(n),n)
            head(queue(cons(x,f),r)) -> x
            head(queue(nil(),r)) -> errorHead()
            rev(xs) -> rev'(xs,nil())
            rev'(cons(x,xs),ys) -> rev'(xs,cons(x,ys))
            rev'(nil(),ys) -> ys
            snoc(queue(f,r),x) -> checkF(queue(f,cons(x,r)))
            tail(queue(cons(x,f),r)) -> checkF(queue(f,r))
            tail(queue(nil(),r)) -> errorTail()
        - Signature:
            {checkF/1,empty/0,enq/1,head/1,rev/1,rev'/2,snoc/2,tail/1} / {0/0,cons/2,errorHead/0,errorTail/0,nil/0
            ,queue/2,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {checkF,empty,enq,head,rev,rev',snoc
            ,tail} and constructors {0,cons,errorHead,errorTail,nil,queue,s}
    + Applied Processor:
        Ara {minDegree = 1, maxDegree = 2, araTimeout = 3, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          F (TrsFun "0") :: [] -(0)-> "A"(15)
          F (TrsFun "checkF") :: ["A"(6)] -(3)-> "A"(6)
          F (TrsFun "cons") :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          F (TrsFun "cons") :: ["A"(0) x "A"(6)] -(6)-> "A"(6)
          F (TrsFun "empty") :: [] -(8)-> "A"(8)
          F (TrsFun "enq") :: ["A"(15)] -(9)-> "A"(6)
          F (TrsFun "errorHead") :: [] -(0)-> "A"(7)
          F (TrsFun "errorTail") :: [] -(0)-> "A"(7)
          F (TrsFun "head") :: ["A"(10)] -(2)-> "A"(0)
          F (TrsFun "nil") :: [] -(0)-> "A"(0)
          F (TrsFun "nil") :: [] -(0)-> "A"(6)
          F (TrsFun "nil") :: [] -(0)-> "A"(15)
          F (TrsFun "nil") :: [] -(0)-> "A"(7)
          F (TrsFun "queue") :: ["A"(0) x "A"(6)] -(0)-> "A"(6)
          F (TrsFun "queue") :: ["A"(0) x "A"(10)] -(0)-> "A"(10)
          F (TrsFun "queue") :: ["A"(0) x "A"(8)] -(0)-> "A"(8)
          F (TrsFun "rev") :: ["A"(6)] -(2)-> "A"(0)
          F (TrsFun "rev'") :: ["A"(6) x "A"(0)] -(1)-> "A"(0)
          F (TrsFun "s") :: ["A"(15)] -(15)-> "A"(15)
          F (TrsFun "snoc") :: ["A"(6) x "A"(0)] -(12)-> "A"(6)
          F (TrsFun "tail") :: ["A"(8)] -(12)-> "A"(0)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "F (TrsFun \"0\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"cons\")_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1)
          "F (TrsFun \"errorHead\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"errorTail\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"nil\")_A" :: [] -(0)-> "A"(1)
          "F (TrsFun \"queue\")_A" :: ["A"(0) x "A"(1)] -(0)-> "A"(1)
          "F (TrsFun \"s\")_A" :: ["A"(1)] -(1)-> "A"(1)
        

WORST_CASE(?,O(n^1))