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 {araHeuristics = NoHeuristics, minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          0 :: [] -(0)-> "A"(15)
          checkF :: ["A"(7)] -(5)-> "A"(7)
          cons :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          cons :: ["A"(0) x "A"(1)] -(1)-> "A"(1)
          cons :: ["A"(0) x "A"(7)] -(7)-> "A"(7)
          empty :: [] -(11)-> "A"(7)
          enq :: ["A"(15)] -(12)-> "A"(7)
          errorHead :: [] -(0)-> "A"(6)
          errorTail :: [] -(0)-> "A"(7)
          head :: ["A"(11)] -(9)-> "A"(0)
          nil :: [] -(0)-> "A"(0)
          nil :: [] -(0)-> "A"(1)
          nil :: [] -(0)-> "A"(15)
          nil :: [] -(0)-> "A"(7)
          queue :: ["A"(0) x "A"(7)] -(7)-> "A"(7)
          queue :: ["A"(0) x "A"(11)] -(11)-> "A"(11)
          queue :: ["A"(0) x "A"(8)] -(8)-> "A"(8)
          rev :: ["A"(1)] -(4)-> "A"(0)
          rev' :: ["A"(1) x "A"(0)] -(2)-> "A"(0)
          s :: ["A"(15)] -(15)-> "A"(15)
          snoc :: ["A"(7) x "A"(0)] -(14)-> "A"(7)
          tail :: ["A"(11)] -(3)-> "A"(1)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "0_A" :: [] -(0)-> "A"(1)
          "cons_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1)
          "errorHead_A" :: [] -(0)-> "A"(1)
          "errorTail_A" :: [] -(0)-> "A"(1)
          "nil_A" :: [] -(0)-> "A"(1)
          "queue_A" :: ["A"(0) x "A"(1)] -(1)-> "A"(1)
          "s_A" :: ["A"(1)] -(1)-> "A"(1)
        

WORST_CASE(?,O(n^1))