tip files outputed by stainless before a solver crash, some are not parseable!

AbstractRefinementMap.scala-0.tip

(declare-datatypes (A1!36 R!59) ((fun1!8 (fun1!10 (f!148 (=> A1!36 R!59)) (pre!89 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!1 (Positive!2 (i!53 Int)))))

(declare-const f!28 (fun1!8 Positive!1 Positive!1))

(datatype-invariant thiss!1 Positive!1 (> (i!53 thiss!1) 0))

(assert (not (=> (@ (f!148 (fun1!10 (pre!89 f!28) (lambda ((x!187 Positive!1)) true))) (Positive!2 1)) (let ((res!102 (@ (f!148 f!28) (Positive!2 1)))) (> (i!53 res!102) 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-1.tip

(declare-datatypes () ((A!73 (Cons!18 (head!32 Int) (tail!37 A!73)) (Nil!18 (i!51 Int)))))

(declare-const a!18 A!73)

(define-fun-rec sum!0 ((a!18 A!73)) Int (let ((i!16 (ite (is-Cons!18 a!18) (+ (head!32 a!18) (sum!0 (tail!37 a!18))) (i!51 a!18)))) (assume (>= i!16 0) i!16)))

(define-fun inv!5 ((thiss!6 A!73)) Bool (>= (i!51 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!73)) Int (assume (or (is-Cons!18 thiss!5) (is-Nil!18 thiss!5)) (let ((i!14 (ite (is-Cons!18 thiss!5) (+ 1 (size!1 (tail!37 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!73)) Bool (ite (is-Nil!18 thiss!8) (inv!5 (assume (is-Nil!18 thiss!8) thiss!8)) (ite (is-Cons!18 thiss!8) (= (head!32 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!73 (inv!4 (assume true thiss!3)))

(assert (not (let ((i!46 (ite (is-Cons!18 a!18) (+ (head!32 a!18) (sum!0 (tail!37 a!18))) (i!51 a!18)))) (>= i!46 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-10.tip

(declare-datatypes (A!63) ((array!34 (array!35 (arr!18 (Array (_ BitVec 32) A!63)) (size!38 (_ BitVec 32))))))

(declare-datatypes () ((A1!100 (A1!101 (x!306 (_ BitVec 32))))))

(declare-datatypes () ((B!63 (B!64 (t!87 (array!34 A1!100))))))

(declare-const b!13 B!63)

(datatype-invariant (par (A!49) array!7 (array!34 A!49) (bvsge (size!38 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!38 (t!87 b!13)) #b00000000000000000000000000000000) (bvsgt (x!306 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!38 (t!87 b!13)))) (select (arr!18 (t!87 b!13)) #b00000000000000000000000000000000))) #b00000000000000000000000000000000)) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!38 (t!87 b!13)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-100.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-101.tip

(declare-datatypes () ((List!70 (Cons!112 (head!159 (_ BitVec 32)) (tail!165 List!70)) (Nil!112))))

(declare-datatypes () ((AbsQueue!27 (Queue!27 (front!34 List!70) (rear!33 List!70)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!27)) Bool (ite (and (is-Queue!27 queue!2) (is-Nil!112 (front!34 queue!2)) (is-Nil!112 (rear!33 queue!2))) true false))

(declare-const queue!7 AbsQueue!27)

(define-fun-rec size!2 ((list!0 List!70)) Int (let ((x$1!6 (ite (is-Nil!112 list!0) 0 (+ 1 (size!2 (tail!165 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!27)) Bool (>= (size!2 (front!34 queue!1)) (size!2 (rear!33 queue!1))))

(define-fun-rec content!4 ((l!21 List!70)) (Set (_ BitVec 32)) (ite (is-Nil!112 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!159 l!21)) (content!4 (tail!165 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!70) (l2!10 List!70)) List!70 (let ((res!35 (ite (is-Nil!112 l1!12) l2!10 (Cons!112 (head!159 l1!12) (concat!0 (tail!165 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!70)) List!70 (let ((x$2!4 (ite (is-Nil!112 l!22) Nil!112 (concat!0 (reverse!1 (tail!165 l!22)) (Cons!112 (head!159 l!22) Nil!112))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun amortizedQueue!0 ((front!3 List!70) (rear!3 List!70)) AbsQueue!27 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!27 front!3 rear!3) (Queue!27 (concat!0 front!3 (reverse!1 rear!3)) Nil!112)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!27) (elem!1 (_ BitVec 32))) AbsQueue!27 (let ((x$4!1 (amortizedQueue!0 (front!34 queue!3) (Cons!112 elem!1 (rear!33 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const elem!4 (_ BitVec 32))

(assert (not (=> (isEmpty!2 queue!7) (and (isAmortized!0 (enqueue!0 queue!7 elem!4)) (not (isEmpty!2 (enqueue!0 queue!7 elem!4)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-102.tip

(declare-datatypes () ((List!71 (Cons!113 (head!160 (_ BitVec 32)) (tail!166 List!71)) (Nil!113))))

(declare-datatypes () ((AbsQueue!28 (Queue!28 (front!35 List!71) (rear!34 List!71)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!28)) Bool (ite (and (is-Queue!28 queue!2) (is-Nil!113 (front!35 queue!2)) (is-Nil!113 (rear!34 queue!2))) true false))

(declare-const queue!8 AbsQueue!28)

(define-fun-rec size!2 ((list!0 List!71)) Int (let ((x$1!6 (ite (is-Nil!113 list!0) 0 (+ 1 (size!2 (tail!166 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!71)) (Set (_ BitVec 32)) (ite (is-Nil!113 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!160 l!21)) (content!4 (tail!166 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!71) (l2!10 List!71)) List!71 (let ((res!35 (ite (is-Nil!113 l1!12) l2!10 (Cons!113 (head!160 l1!12) (concat!0 (tail!166 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!71)) List!71 (let ((x$2!4 (ite (is-Nil!113 l!22) Nil!113 (concat!0 (reverse!1 (tail!166 l!22)) (Cons!113 (head!160 l!22) Nil!113))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!28)) Bool (>= (size!2 (front!35 queue!1)) (size!2 (rear!34 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!71) (rear!3 List!71)) AbsQueue!28 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!28 front!3 rear!3) (Queue!28 (concat!0 front!3 (reverse!1 rear!3)) Nil!113)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!28) (elem!1 (_ BitVec 32))) AbsQueue!28 (let ((x$4!1 (amortizedQueue!0 (front!35 queue!3) (Cons!113 elem!1 (rear!34 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!28)) (_ BitVec 32) (head!160 (front!35 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!28)) AbsQueue!28 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!166 (front!35 queue!4)) (rear!34 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (and (isAmortized!0 q4!0) (not (isEmpty!2 q4!0)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-103.tip

(declare-datatypes () ((KeyValuePairAbs!5 (KeyValuePair!5 (key!13 (_ BitVec 32)) (value!44 (_ BitVec 32))))))

(declare-datatypes () ((List!74 (Cons!116 (head!163 KeyValuePairAbs!5) (tail!169 List!74)) (Nil!116))))

(declare-const l2!11 List!74)

(assert (not (or (is-Nil!116 l2!11) (is-Cons!116 l2!11))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-104.tip

(declare-datatypes () ((KeyValuePairAbs!7 (KeyValuePair!7 (key!15 (_ BitVec 32)) (value!46 (_ BitVec 32))))))

(declare-datatypes () ((List!76 (Cons!118 (head!165 KeyValuePairAbs!7) (tail!171 List!76)) (Nil!118))))

(declare-const l!26 List!76)

(assert (not (or (is-Nil!118 l!26) (and (is-Cons!118 l!26) (is-KeyValuePair!7 (head!165 l!26))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-105.tip

(declare-datatypes () ((KeyValuePairAbs!9 (KeyValuePair!9 (key!17 (_ BitVec 32)) (value!48 (_ BitVec 32))))))

(declare-datatypes () ((List!79 (Cons!121 (head!168 KeyValuePairAbs!9) (tail!174 List!79)) (Nil!121))))

(declare-const l!25 List!79)

(assert (not (or (is-Nil!121 l!25) (and (is-Cons!121 l!25) (is-KeyValuePair!9 (head!168 l!25))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-106.tip

(declare-datatypes () ((List!78 (Cons!120 (head!167 (_ BitVec 32)) (tail!173 List!78)) (Nil!120))))

(declare-const l!22 List!78)

(assert (not (or (is-Nil!120 l!22) (is-Cons!120 l!22))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-107.tip

(declare-datatypes () ((KeyValuePairAbs!11 (KeyValuePair!11 (key!19 (_ BitVec 32)) (value!50 (_ BitVec 32))))))

(declare-datatypes () ((List!82 (Cons!124 (head!171 KeyValuePairAbs!11) (tail!177 List!82)) (Nil!124))))

(declare-const l!26 List!82)

(declare-const e!6 KeyValuePairAbs!11)

(assert (not (=> (and (not (is-Nil!124 l!26)) (is-Cons!124 l!26) (is-KeyValuePair!11 (head!171 l!26))) (let ((k!5 (key!19 (head!171 l!26)))) (let ((v!10 (value!50 (head!171 l!26)))) (let ((xs!32 (tail!177 l!26))) (is-KeyValuePair!11 e!6)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-108.tip

(declare-datatypes () ((KeyValuePairAbs!13 (KeyValuePair!13 (key!21 (_ BitVec 32)) (value!52 (_ BitVec 32))))))

(declare-datatypes () ((List!84 (Cons!126 (head!173 KeyValuePairAbs!13) (tail!179 List!84)) (Nil!126))))

(declare-const l!27 List!84)

(declare-datatypes () ((OptionInt!2 (None!9) (Some!9 (i!118 (_ BitVec 32))))))

(define-fun-rec find!1 ((l!24 List!84) (e!5 (_ BitVec 32))) OptionInt!2 (ite (is-Nil!126 l!24) None!9 (ite (= (key!21 (head!173 l!24)) e!5) (Some!9 (value!52 (head!173 l!24))) (find!1 (tail!179 l!24) e!5))))

(define-fun-rec domain!0 ((l!23 List!84)) (Set (_ BitVec 32)) (ite (is-Nil!126 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!21 (head!173 l!23))) (domain!0 (tail!179 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!84) (e!6 KeyValuePairAbs!13)) List!84 (let ((res!41 (ite (is-Nil!126 l!26) (Cons!126 e!6 Nil!126) (ite (= (key!21 e!6) (key!21 (head!173 l!26))) (Cons!126 (KeyValuePair!13 (key!21 e!6) (value!52 e!6)) (tail!179 l!26)) (Cons!126 (KeyValuePair!13 (key!21 (head!173 l!26)) (value!52 (head!173 l!26))) (updateElem!0 (tail!179 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!21 e!6)))) res!41)))

(declare-const k2!0 (_ BitVec 32))

(declare-const e!7 (_ BitVec 32))

(declare-const k1!0 (_ BitVec 32))

(assert (not (=> (and (is-Cons!126 l!27) (= (find!1 (updateElem!0 (tail!179 l!27) (KeyValuePair!13 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!9 e!7) (find!1 (tail!179 l!27) k1!0)))) (= (find!1 (updateElem!0 l!27 (KeyValuePair!13 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!9 e!7) (find!1 l!27 k1!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-109.tip

(declare-datatypes () ((List!86 (Cons!128 (head!175 (_ BitVec 32)) (tail!181 List!86)) (Nil!128))))

(declare-const l1!12 List!86)

(declare-const l2!10 List!86)

(define-fun-rec size!2 ((list!0 List!86)) Int (let ((x$1!6 (ite (is-Nil!128 list!0) 0 (+ 1 (size!2 (tail!181 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!86)) (Set (_ BitVec 32)) (ite (is-Nil!128 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!175 l!21)) (content!4 (tail!181 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!86) (l2!10 List!86)) List!86 (let ((res!35 (ite (is-Nil!128 l1!12) l2!10 (Cons!128 (head!175 l1!12) (concat!0 (tail!181 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(assert (not (let ((res!283 (ite (is-Nil!128 l1!12) l2!10 (Cons!128 (head!175 l1!12) (concat!0 (tail!181 l1!12) l2!10))))) (and (= (size!2 res!283) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!283) (union (content!4 l1!12) (content!4 l2!10)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-11.tip

(declare-datatypes (A1!36 R!59) ((fun1!32 (fun1!33 (f!198 (=> A1!36 R!59)) (pre!101 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!5 (Positive!6 (i!71 Int)))))

(declare-const f!28 (fun1!32 Positive!5 Positive!5))

(datatype-invariant thiss!1 Positive!5 (> (i!71 thiss!1) 0))

(assert (not (@ (f!198 (fun1!33 (pre!101 (fun1!33 (pre!101 f!28) (lambda ((x!312 Positive!5)) true))) (lambda ((x!313 Positive!5)) true))) (Positive!6 1))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-110.tip

(declare-datatypes () ((KeyValuePairAbs!15 (KeyValuePair!15 (key!23 (_ BitVec 32)) (value!54 (_ BitVec 32))))))

(declare-datatypes () ((List!88 (Cons!130 (head!177 KeyValuePairAbs!15) (tail!183 List!88)) (Nil!130))))

(declare-const l!26 List!88)

(declare-const e!6 KeyValuePairAbs!15)

(define-fun-rec domain!0 ((l!23 List!88)) (Set (_ BitVec 32)) (ite (is-Nil!130 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!23 (head!177 l!23))) (domain!0 (tail!183 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!88) (e!6 KeyValuePairAbs!15)) List!88 (let ((res!41 (ite (is-Nil!130 l!26) (Cons!130 e!6 Nil!130) (ite (= (key!23 e!6) (key!23 (head!177 l!26))) (Cons!130 (KeyValuePair!15 (key!23 e!6) (value!54 e!6)) (tail!183 l!26)) (Cons!130 (KeyValuePair!15 (key!23 (head!177 l!26)) (value!54 (head!177 l!26))) (updateElem!0 (tail!183 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!23 e!6)))) res!41)))

(assert (not (let ((res!41 (ite (is-Nil!130 l!26) (Cons!130 e!6 Nil!130) (ite (= (key!23 e!6) (key!23 (head!177 l!26))) (Cons!130 (KeyValuePair!15 (key!23 e!6) (value!54 e!6)) (tail!183 l!26)) (Cons!130 (KeyValuePair!15 (key!23 (head!177 l!26)) (value!54 (head!177 l!26))) (updateElem!0 (tail!183 l!26) e!6)))))) (is-KeyValuePair!15 e!6))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-111.tip

(declare-datatypes () ((KeyValuePairAbs!17 (KeyValuePair!17 (key!25 (_ BitVec 32)) (value!56 (_ BitVec 32))))))

(declare-datatypes () ((List!90 (Cons!132 (head!179 KeyValuePairAbs!17) (tail!185 List!90)) (Nil!132))))

(declare-const l!23 List!90)

(assert (not (or (is-Nil!132 l!23) (and (is-Cons!132 l!23) (is-KeyValuePair!17 (head!179 l!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-112.tip

(declare-datatypes () ((KeyValuePairAbs!19 (KeyValuePair!19 (key!27 (_ BitVec 32)) (value!58 (_ BitVec 32))))))

(declare-datatypes () ((List!92 (Cons!134 (head!181 KeyValuePairAbs!19) (tail!187 List!92)) (Nil!134))))

(declare-const l!24 List!92)

(assert (not (or (is-Nil!134 l!24) (and (is-Cons!134 l!24) (is-KeyValuePair!19 (head!181 l!24))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-113.tip

(declare-datatypes () ((List!94 (Cons!136 (head!183 (_ BitVec 32)) (tail!189 List!94)) (Nil!136))))

(declare-const l!21 List!94)

(assert (not (or (is-Nil!136 l!21) (is-Cons!136 l!21))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-114.tip

(declare-datatypes () ((List!96 (Cons!138 (head!185 (_ BitVec 32)) (tail!191 List!96)) (Nil!138))))

(declare-datatypes () ((AbsQueue!31 (Queue!31 (front!38 List!96) (rear!37 List!96)))))

(declare-const queue!1 AbsQueue!31)

(assert (not (is-Queue!31 queue!1)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-115.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!51 (fun2!52 (f!554 (=> A1!271 A2!189 R!294)) (pre!380 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!51 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!51 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!554 f!32) x!77 y!9) (@ (f!554 f!32) y!9 x!77))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!554 (fun2!52 (pre!380 f!35) (lambda ((x!902 Int) (x!903 Int)) true))) x!657 x!658)) (isCommutative!0 f!35)) (forall ((x!655 Int)(x!656 Int)) (@ (f!554 (fun2!52 (pre!380 f!35) (lambda ((x!904 Int) (x!905 Int)) true))) x!655 x!656)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-116.tip

(declare-datatypes () ((List!98 (Cons!140 (head!187 (_ BitVec 32)) (tail!193 List!98)) (Nil!140))))

(declare-const l1!12 List!98)

(assert (not (or (is-Nil!140 l1!12) (is-Cons!140 l1!12))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-117.tip

(declare-datatypes () ((List!100 (Cons!142 (head!189 (_ BitVec 32)) (tail!195 List!100)) (Nil!142))))

(declare-const list!0 List!100)

(define-fun-rec size!2 ((list!0 List!100)) Int (let ((x$1!6 (ite (is-Nil!142 list!0) 0 (+ 1 (size!2 (tail!195 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(assert (not (let ((x$1!77 (ite (is-Nil!142 list!0) 0 (+ 1 (size!2 (tail!195 list!0)))))) (>= x$1!77 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-118.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!55 (fun2!56 (f!557 (=> A1!271 A2!189 R!294)) (pre!382 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!55 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!55 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!557 f!32) x!77 y!9) (@ (f!557 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!55 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!557 f!33) (@ (f!557 f!33) x!78 y!10) z!10) (@ (f!557 f!33) (@ (f!557 f!33) y!10 z!10) x!78))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!557 (fun2!56 (pre!382 f!35) (lambda ((x!928 Int) (x!929 Int)) true))) x!657 x!658)) (isCommutative!0 f!35) (isRotate!0 f!35)) (forall ((x!649 Int)(x!650 Int)) (@ (f!557 (fun2!56 (pre!382 f!35) (lambda ((x!930 Int) (x!931 Int)) true))) x!649 x!650)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-119.tip

(declare-datatypes () ((KeyValuePairAbs!21 (KeyValuePair!21 (key!29 (_ BitVec 32)) (value!60 (_ BitVec 32))))))

(declare-datatypes () ((List!102 (Cons!144 (head!191 KeyValuePairAbs!21) (tail!197 List!102)) (Nil!144))))

(declare-const l!27 List!102)

(declare-datatypes () ((OptionInt!4 (None!11) (Some!11 (i!120 (_ BitVec 32))))))

(define-fun-rec find!1 ((l!24 List!102) (e!5 (_ BitVec 32))) OptionInt!4 (ite (is-Nil!144 l!24) None!11 (ite (= (key!29 (head!191 l!24)) e!5) (Some!11 (value!60 (head!191 l!24))) (find!1 (tail!197 l!24) e!5))))

(define-fun-rec domain!0 ((l!23 List!102)) (Set (_ BitVec 32)) (ite (is-Nil!144 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!29 (head!191 l!23))) (domain!0 (tail!197 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!102) (e!6 KeyValuePairAbs!21)) List!102 (let ((res!41 (ite (is-Nil!144 l!26) (Cons!144 e!6 Nil!144) (ite (= (key!29 e!6) (key!29 (head!191 l!26))) (Cons!144 (KeyValuePair!21 (key!29 e!6) (value!60 e!6)) (tail!197 l!26)) (Cons!144 (KeyValuePair!21 (key!29 (head!191 l!26)) (value!60 (head!191 l!26))) (updateElem!0 (tail!197 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!29 e!6)))) res!41)))

(declare-const k2!0 (_ BitVec 32))

(declare-const e!7 (_ BitVec 32))

(declare-const k1!0 (_ BitVec 32))

(assert (not (=> (is-Nil!144 l!27) (= (find!1 (updateElem!0 l!27 (KeyValuePair!21 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!11 e!7) (find!1 l!27 k1!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-12.tip

(declare-datatypes () ((Pos!5 (Pos!6 (i!69 Int)))))

(define-fun inv!3 ((thiss!0 Pos!5)) Bool (> (i!69 thiss!0) 0))

(declare-const p!23 Pos!5)

(datatype-invariant thiss!0 Pos!5 (> (i!69 thiss!0) 0))

(assert (not (inv!3 (Pos!6 (+ (i!69 p!23) 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-120.tip

(declare-datatypes () ((List!103 (Cons!145 (head!192 (_ BitVec 32)) (tail!198 List!103)) (Nil!145))))

(declare-const list!0 List!103)

(assert (not (or (is-Nil!145 list!0) (is-Cons!145 list!0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-121.tip

(declare-datatypes () ((List!106 (Cons!148 (head!195 (_ BitVec 32)) (tail!201 List!106)) (Nil!148))))

(declare-datatypes () ((AbsQueue!33 (Queue!33 (front!40 List!106) (rear!39 List!106)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!33)) Bool (ite (and (is-Queue!33 queue!2) (is-Nil!148 (front!40 queue!2)) (is-Nil!148 (rear!39 queue!2))) true false))

(declare-const queue!7 AbsQueue!33)

(define-fun front!5 ((queue!5 AbsQueue!33)) (_ BitVec 32) (head!195 (front!40 queue!5)))

(define-fun-rec size!2 ((list!0 List!106)) Int (let ((x$1!6 (ite (is-Nil!148 list!0) 0 (+ 1 (size!2 (tail!201 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!106)) (Set (_ BitVec 32)) (ite (is-Nil!148 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!195 l!21)) (content!4 (tail!201 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!106) (l2!10 List!106)) List!106 (let ((res!35 (ite (is-Nil!148 l1!12) l2!10 (Cons!148 (head!195 l1!12) (concat!0 (tail!201 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!106)) List!106 (let ((x$2!4 (ite (is-Nil!148 l!22) Nil!148 (concat!0 (reverse!1 (tail!201 l!22)) (Cons!148 (head!195 l!22) Nil!148))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!33)) Bool (>= (size!2 (front!40 queue!1)) (size!2 (rear!39 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!106) (rear!3 List!106)) AbsQueue!33 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!33 front!3 rear!3) (Queue!33 (concat!0 front!3 (reverse!1 rear!3)) Nil!148)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!33) (elem!1 (_ BitVec 32))) AbsQueue!33 (let ((x$4!1 (amortizedQueue!0 (front!40 queue!3) (Cons!148 elem!1 (rear!39 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const elem!4 (_ BitVec 32))

(assert (not (ite (isEmpty!2 queue!7) (= (front!5 (enqueue!0 queue!7 elem!4)) elem!4) true)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-122.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!59 (fun2!60 (f!561 (=> A1!271 A2!189 R!294)) (pre!384 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!59 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!59 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!561 f!32) x!77 y!9) (@ (f!561 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!59 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!561 f!33) (@ (f!561 f!33) x!78 y!10) z!10) (@ (f!561 f!33) (@ (f!561 f!33) y!10 z!10) x!78))))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!59 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!561 f!31) (@ (f!561 f!31) x!76 y!8) z!9) (@ (f!561 f!31) x!76 (@ (f!561 f!31) y!8 z!9)))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!561 (fun2!60 (pre!384 f!35) (lambda ((x!963 Int) (x!964 Int)) true))) x!657 x!658)) (isCommutative!0 f!35) (isRotate!0 f!35)) (isAssociative!0 f!35))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-123.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!63 (fun2!64 (f!566 (=> A1!271 A2!189 R!294)) (pre!386 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!63 A!40 A!40 A!40))))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!566 (fun2!64 (pre!386 (as f!33 (fun2!63 A!40 A!40 A!40))) (lambda ((x!975 A!40) (x!976 A!40)) true))) x!655 x!656)) (@ (f!566 (fun2!64 (pre!386 (as f!33 (fun2!63 A!40 A!40 A!40))) (lambda ((x!977 A!40) (x!978 A!40)) true))) (as y!10 A!40) (as z!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-124.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!68 (fun2!69 (f!579 (=> A1!271 A2!189 R!294)) (pre!399 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!68 A!39 A!39 A!39))))

(declare-const (par (A!39) (x!645 A!39)))

(declare-const (par (A!39) (x!646 A!39)))

(assert (par (A!39) (not (@ (f!579 (fun2!69 (pre!399 (fun2!69 (pre!399 (as f!32 (fun2!68 A!39 A!39 A!39))) (lambda ((x!1011 A!39) (x!1012 A!39)) true))) (lambda ((x!1013 A!39) (x!1014 A!39)) true))) (as x!645 A!39) (as x!646 A!39)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-125.tip

(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!198 (array!199 (arr!100 (Array (_ BitVec 32) A!297)) (size!142 (_ BitVec 32))))))

(declare-const arr!0 (array!198 (_ BitVec 32)))

(declare-const x!83 (_ BitVec 32))

(datatype-invariant (par (A!296) array!197 (array!198 A!296) (bvsge (size!142 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!142 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (let ((y!13 (assume (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!142 arr!0))) (select (arr!100 arr!0) i!22)))) (=> (and (not (= x!83 y!13)) (bvslt x!83 y!13)) (and (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd (bvsub i!22 #b00000000000000000000000000000001) #b00000000000000000000000000000001))) (bvslt (bvsub i!22 #b00000000000000000000000000000001) (size!142 arr!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-126.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!72 (fun2!73 (f!581 (=> A1!271 A2!189 R!294)) (pre!401 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!72 A!39 A!39 A!39))))

(declare-const (par (A!39) (x!77 A!39)))

(declare-const (par (A!39) (y!9 A!39)))

(assert (par (A!39) (not (=> (forall ((x!645 A!39)(x!646 A!39)) (@ (f!581 (fun2!73 (pre!401 (as f!32 (fun2!72 A!39 A!39 A!39))) (lambda ((x!1023 A!39) (x!1024 A!39)) true))) x!645 x!646)) (@ (f!581 (fun2!73 (pre!401 (as f!32 (fun2!72 A!39 A!39 A!39))) (lambda ((x!1025 A!39) (x!1026 A!39)) true))) (as x!77 A!39) (as y!9 A!39))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-127.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!76 (fun2!77 (f!583 (=> A1!271 A2!189 R!294)) (pre!403 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!76 A!39 A!39 A!39))))

(declare-const (par (A!39) (y!9 A!39)))

(declare-const (par (A!39) (x!77 A!39)))

(assert (par (A!39) (not (=> (forall ((x!645 A!39)(x!646 A!39)) (@ (f!583 (fun2!77 (pre!403 (as f!32 (fun2!76 A!39 A!39 A!39))) (lambda ((x!1039 A!39) (x!1040 A!39)) true))) x!645 x!646)) (@ (f!583 (fun2!77 (pre!403 (as f!32 (fun2!76 A!39 A!39 A!39))) (lambda ((x!1041 A!39) (x!1042 A!39)) true))) (as y!9 A!39) (as x!77 A!39))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-128.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!80 (fun2!81 (f!585 (=> A1!271 A2!189 R!294)) (pre!405 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!80 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!649 A!38)))

(declare-const (par (A!38) (x!650 A!38)))

(assert (par (A!38) (not (@ (f!585 (fun2!81 (pre!405 (fun2!81 (pre!405 (as f!31 (fun2!80 A!38 A!38 A!38))) (lambda ((x!1052 A!38) (x!1053 A!38)) true))) (lambda ((x!1054 A!38) (x!1055 A!38)) true))) (as x!649 A!38) (as x!650 A!38)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-129.tip

(declare-datatypes () ((List!108 (Cons!152 (head!199 (_ BitVec 32)) (tail!205 List!108)) (Nil!152))))

(declare-datatypes () ((AbsQueue!35 (Queue!35 (front!42 List!108) (rear!41 List!108)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!35)) Bool (ite (and (is-Queue!35 queue!2) (is-Nil!152 (front!42 queue!2)) (is-Nil!152 (rear!41 queue!2))) true false))

(declare-const queue!8 AbsQueue!35)

(define-fun-rec size!2 ((list!0 List!108)) Int (let ((x$1!6 (ite (is-Nil!152 list!0) 0 (+ 1 (size!2 (tail!205 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!108)) (Set (_ BitVec 32)) (ite (is-Nil!152 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!199 l!21)) (content!4 (tail!205 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!108) (l2!10 List!108)) List!108 (let ((res!35 (ite (is-Nil!152 l1!12) l2!10 (Cons!152 (head!199 l1!12) (concat!0 (tail!205 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!108)) List!108 (let ((x$2!4 (ite (is-Nil!152 l!22) Nil!152 (concat!0 (reverse!1 (tail!205 l!22)) (Cons!152 (head!199 l!22) Nil!152))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!35)) Bool (>= (size!2 (front!42 queue!1)) (size!2 (rear!41 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!108) (rear!3 List!108)) AbsQueue!35 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!35 front!3 rear!3) (Queue!35 (concat!0 front!3 (reverse!1 rear!3)) Nil!152)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!35) (elem!1 (_ BitVec 32))) AbsQueue!35 (let ((x$4!1 (amortizedQueue!0 (front!42 queue!3) (Cons!152 elem!1 (rear!41 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!35)) (_ BitVec 32) (head!199 (front!42 queue!5)))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (and (isAmortized!0 q3!0) (not (isEmpty!2 q3!0))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-13.tip

(declare-datatypes () ((Positive!9 (Positive!10 (i!75 Int)))))

(define-fun inv!2 ((thiss!1 Positive!9)) Bool (> (i!75 thiss!1) 0))

(datatype-invariant thiss!1 Positive!9 (> (i!75 thiss!1) 0))

(assert (not (inv!2 (Positive!10 1))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-130.tip

(declare-datatypes () ((Tree!5 (Leaf!4) (Node!9 (left!35 Tree!5) (value!64 Int) (right!37 Tree!5)))))

(declare-const v!14 Int)

(define-fun-rec content!5 ((tree!0 Tree!5)) (Set Int) (ite (is-Leaf!4 tree!0) (as emptyset Int) (union (union (content!5 (left!35 tree!0)) (insert (as emptyset Int) (value!64 tree!0))) (content!5 (right!37 tree!0)))))

(assert (not (let ((x$1!83 (Node!9 Leaf!4 v!14 Leaf!4))) (= (content!5 x$1!83) (insert (as emptyset Int) v!14)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-131.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!85 (fun2!86 (f!598 (=> A1!271 A2!189 R!294)) (pre!418 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!85 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!598 (fun2!86 (pre!418 (as f!31 (fun2!85 A!38 A!38 A!38))) (lambda ((x!1065 A!38) (x!1066 A!38)) true))) x!649 x!650)) (@ (f!598 (fun2!86 (pre!418 (as f!31 (fun2!85 A!38 A!38 A!38))) (lambda ((x!1067 A!38) (x!1068 A!38)) true))) (@ (f!598 (as f!31 (fun2!85 A!38 A!38 A!38))) (as x!76 A!38) (as y!8 A!38)) (as z!9 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-132.tip

(declare-datatypes () ((List!110 (Cons!154 (head!201 (_ BitVec 32)) (tail!207 List!110)) (Nil!154))))

(declare-datatypes () ((AbsQueue!37 (Queue!37 (front!44 List!110) (rear!43 List!110)))))

(define-fun-rec size!2 ((list!0 List!110)) Int (let ((x$1!6 (ite (is-Nil!154 list!0) 0 (+ 1 (size!2 (tail!207 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!110)) (Set (_ BitVec 32)) (ite (is-Nil!154 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!201 l!21)) (content!4 (tail!207 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!110) (l2!10 List!110)) List!110 (let ((res!35 (ite (is-Nil!154 l1!12) l2!10 (Cons!154 (head!201 l1!12) (concat!0 (tail!207 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!110)) List!110 (let ((x$2!4 (ite (is-Nil!154 l!22) Nil!154 (concat!0 (reverse!1 (tail!207 l!22)) (Cons!154 (head!201 l!22) Nil!154))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!37)) List!110 (concat!0 (front!44 queue!0) (reverse!1 (rear!43 queue!0))))

(declare-const front!6 List!110)

(declare-const rear!6 List!110)

(declare-const list!2 List!110)

(define-fun isEmpty!2 ((queue!2 AbsQueue!37)) Bool (ite (and (is-Queue!37 queue!2) (is-Nil!154 (front!44 queue!2)) (is-Nil!154 (rear!43 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!37)) Bool (>= (size!2 (front!44 queue!1)) (size!2 (rear!43 queue!1))))

(assert (not (=> (and (= (asList!0 (Queue!37 front!6 rear!6)) list!2) (is-Cons!154 list!2)) (let ((xs!27 (tail!207 list!2))) (=> (and (is-Cons!154 rear!6) (not (isEmpty!2 (Queue!37 front!6 rear!6))) (isAmortized!0 (Queue!37 front!6 rear!6)) (=> (and (= (asList!0 (Queue!37 front!6 (tail!207 rear!6))) list!2) (is-Cons!154 list!2)) (let ((xs!108 (tail!207 list!2))) (and (isAmortized!0 (Queue!37 front!6 (tail!207 rear!6))) (not (isEmpty!2 (Queue!37 front!6 (tail!207 rear!6)))))))) (and (isAmortized!0 (Queue!37 front!6 rear!6)) (not (isEmpty!2 (Queue!37 front!6 rear!6)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-133.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!89 (fun2!90 (f!600 (=> A1!271 A2!189 R!294)) (pre!420 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!89 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!600 (fun2!90 (pre!420 (as f!31 (fun2!89 A!38 A!38 A!38))) (lambda ((x!1081 A!38) (x!1082 A!38)) true))) x!649 x!650)) (@ (f!600 (fun2!90 (pre!420 (as f!31 (fun2!89 A!38 A!38 A!38))) (lambda ((x!1083 A!38) (x!1084 A!38)) true))) (as x!76 A!38) (as y!8 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-134.tip

(declare-datatypes () ((Tree!7 (Leaf!6) (Node!11 (left!37 Tree!7) (value!66 Int) (right!39 Tree!7)))))

(define-fun-rec content!5 ((tree!0 Tree!7)) (Set Int) (ite (is-Leaf!6 tree!0) (as emptyset Int) (union (union (content!5 (left!37 tree!0)) (insert (as emptyset Int) (value!66 tree!0))) (content!5 (right!39 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!7)) Bool (ite (is-Leaf!6 tree!1) true (and (and (and (isBST!0 (left!37 tree!1)) (isBST!0 (right!39 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!37 tree!1))) (< x!84 (value!66 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!39 tree!1))) (< (value!66 tree!1) x!85))))))

(declare-const tree!2 Tree!7)

(declare-const value!2 Int)

(assert (not (=> (and (isBST!0 tree!2) (not (is-Leaf!6 tree!2)) (is-Node!11 tree!2)) (let ((l!29 (left!37 tree!2))) (let ((v!13 (value!66 tree!2))) (let ((r!10 (right!39 tree!2))) (=> (< v!13 value!2) (isBST!0 r!10))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-135.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!93 (fun2!94 (f!602 (=> A1!271 A2!189 R!294)) (pre!422 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!93 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!602 (fun2!94 (pre!422 (as f!31 (fun2!93 A!38 A!38 A!38))) (lambda ((x!1097 A!38) (x!1098 A!38)) true))) x!649 x!650)) (@ (f!602 (fun2!94 (pre!422 (as f!31 (fun2!93 A!38 A!38 A!38))) (lambda ((x!1099 A!38) (x!1100 A!38)) true))) (as x!76 A!38) (@ (f!602 (as f!31 (fun2!93 A!38 A!38 A!38))) (as y!8 A!38) (as z!9 A!38)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-136.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!97 (fun2!98 (f!604 (=> A1!271 A2!189 R!294)) (pre!424 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!97 A!38 A!38 A!38))))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!604 (fun2!98 (pre!424 (as f!31 (fun2!97 A!38 A!38 A!38))) (lambda ((x!1110 A!38) (x!1111 A!38)) true))) x!649 x!650)) (@ (f!604 (fun2!98 (pre!424 (as f!31 (fun2!97 A!38 A!38 A!38))) (lambda ((x!1112 A!38) (x!1113 A!38)) true))) (as y!8 A!38) (as z!9 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-137.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!101 (fun2!102 (f!606 (=> A1!271 A2!189 R!294)) (pre!426 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!101 Int Int Int))

(declare-const x!657 Int)

(declare-const x!658 Int)

(assert (not (@ (f!606 (fun2!102 (pre!426 (fun2!102 (pre!426 f!35) (lambda ((x!1114 Int) (x!1115 Int)) true))) (lambda ((x!1116 Int) (x!1117 Int)) true))) x!657 x!658)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-138.tip

(declare-datatypes () ((List!112 (Cons!156 (head!203 (_ BitVec 32)) (tail!209 List!112)) (Nil!156))))

(declare-datatypes () ((AbsQueue!39 (Queue!39 (front!46 List!112) (rear!45 List!112)))))

(define-fun-rec size!2 ((list!0 List!112)) Int (let ((x$1!6 (ite (is-Nil!156 list!0) 0 (+ 1 (size!2 (tail!209 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!112)) (Set (_ BitVec 32)) (ite (is-Nil!156 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!203 l!21)) (content!4 (tail!209 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!112) (l2!10 List!112)) List!112 (let ((res!35 (ite (is-Nil!156 l1!12) l2!10 (Cons!156 (head!203 l1!12) (concat!0 (tail!209 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!112)) List!112 (let ((x$2!4 (ite (is-Nil!156 l!22) Nil!156 (concat!0 (reverse!1 (tail!209 l!22)) (Cons!156 (head!203 l!22) Nil!156))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!39)) List!112 (concat!0 (front!46 queue!0) (reverse!1 (rear!45 queue!0))))

(declare-const front!6 List!112)

(declare-const rear!6 List!112)

(declare-const list!2 List!112)

(define-fun isEmpty!2 ((queue!2 AbsQueue!39)) Bool (ite (and (is-Queue!39 queue!2) (is-Nil!156 (front!46 queue!2)) (is-Nil!156 (rear!45 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!39)) Bool (>= (size!2 (front!46 queue!1)) (size!2 (rear!45 queue!1))))

(assert (not (=> (and (= (asList!0 (Queue!39 front!6 rear!6)) list!2) (is-Cons!156 list!2)) (let ((xs!27 (tail!209 list!2))) (=> (and (is-Nil!156 rear!6) (not (isEmpty!2 (Queue!39 front!6 rear!6))) (isAmortized!0 (Queue!39 front!6 rear!6))) (and (isAmortized!0 (Queue!39 front!6 rear!6)) (not (isEmpty!2 (Queue!39 front!6 rear!6)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-139.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!105 (fun2!106 (f!608 (=> A1!271 A2!189 R!294)) (pre!428 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!105 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!655 A!40)))

(declare-const (par (A!40) (x!656 A!40)))

(assert (par (A!40) (not (@ (f!608 (fun2!106 (pre!428 (fun2!106 (pre!428 (as f!33 (fun2!105 A!40 A!40 A!40))) (lambda ((x!1143 A!40) (x!1144 A!40)) true))) (lambda ((x!1145 A!40) (x!1146 A!40)) true))) (as x!655 A!40) (as x!656 A!40)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-14.tip

(declare-datatypes (T!0) ((List!17 (Cons!26 (h!62 T!0) (t!96 (List!17 T!0))) (Nil!26))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!17 T!29))) (Set T!29) (ite (is-Nil!26 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!62 thiss!4)) (content!0 (t!96 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!17 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!26 thiss!10) (or (= (h!62 thiss!10) v!0) (contains!0 (t!96 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!17 A!31))))

(declare-const (par (A!31) (x!60 A!31)))

(declare-datatypes (A1!50 R!72) ((fun1!38 (fun1!39 (f!201 (=> A1!50 R!72)) (pre!104 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!9 (~>!10 (f!204 (fun1!38 A!30 B!20)) (ens!5 (fun1!38 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!9 A!36 B!28))) (fun1!38 A!36 Bool) (fun1!39 (pre!104 (f!204 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!9 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!9 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!201 (fun1!39 (pre!104 (ens!5 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!201 (fun1!39 (pre!104 (f!204 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!201 (ens!5 thiss!2)) (@ (f!201 (f!204 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (contains!0 (as l!19 (List!17 A!31)) (as x!60 A!31)) (@ (f!201 (fun1!39 (pre!104 (pre!0 (as f!27 (~>!9 A!31 B!21)))) (lambda ((x!326 A!31)) true))) (as x!60 A!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-140.tip

(declare-datatypes () ((Tree!9 (Leaf!8) (Node!13 (left!39 Tree!9) (value!68 Int) (right!41 Tree!9)))))

(define-fun-rec content!5 ((tree!0 Tree!9)) (Set Int) (ite (is-Leaf!8 tree!0) (as emptyset Int) (union (union (content!5 (left!39 tree!0)) (insert (as emptyset Int) (value!68 tree!0))) (content!5 (right!41 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!9)) Bool (ite (is-Leaf!8 tree!1) true (and (and (and (isBST!0 (left!39 tree!1)) (isBST!0 (right!41 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!39 tree!1))) (< x!84 (value!68 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!41 tree!1))) (< (value!68 tree!1) x!85))))))

(declare-const tree!2 Tree!9)

(declare-const value!2 Int)

(assert (not (=> (and (isBST!0 tree!2) (not (is-Leaf!8 tree!2)) (is-Node!13 tree!2)) (let ((l!29 (left!39 tree!2))) (let ((v!13 (value!68 tree!2))) (let ((r!10 (right!41 tree!2))) (=> (and (>= v!13 value!2) (> v!13 value!2)) (isBST!0 l!29))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-141.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!109 (fun2!110 (f!610 (=> A1!271 A2!189 R!294)) (pre!430 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!109 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!78 A!40)))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!610 (fun2!110 (pre!430 (as f!33 (fun2!109 A!40 A!40 A!40))) (lambda ((x!1153 A!40) (x!1154 A!40)) true))) x!655 x!656)) (@ (f!610 (fun2!110 (pre!430 (as f!33 (fun2!109 A!40 A!40 A!40))) (lambda ((x!1155 A!40) (x!1156 A!40)) true))) (@ (f!610 (as f!33 (fun2!109 A!40 A!40 A!40))) (as x!78 A!40) (as y!10 A!40)) (as z!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-142.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!113 (fun2!114 (f!612 (=> A1!271 A2!189 R!294)) (pre!432 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!113 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!78 A!40)))

(declare-const (par (A!40) (y!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!612 (fun2!114 (pre!432 (as f!33 (fun2!113 A!40 A!40 A!40))) (lambda ((x!1168 A!40) (x!1169 A!40)) true))) x!655 x!656)) (@ (f!612 (fun2!114 (pre!432 (as f!33 (fun2!113 A!40 A!40 A!40))) (lambda ((x!1170 A!40) (x!1171 A!40)) true))) (as x!78 A!40) (as y!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-143.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!117 (fun2!118 (f!614 (=> A1!271 A2!189 R!294)) (pre!434 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!117 A!40 A!40 A!40))))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(declare-const (par (A!40) (x!78 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!614 (fun2!118 (pre!434 (as f!33 (fun2!117 A!40 A!40 A!40))) (lambda ((x!1181 A!40) (x!1182 A!40)) true))) x!655 x!656)) (@ (f!614 (fun2!118 (pre!434 (as f!33 (fun2!117 A!40 A!40 A!40))) (lambda ((x!1183 A!40) (x!1184 A!40)) true))) (@ (f!614 (as f!33 (fun2!117 A!40 A!40 A!40))) (as y!10 A!40) (as z!10 A!40)) (as x!78 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-144.tip

(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!204 (array!205 (arr!103 (Array (_ BitVec 32) A!297)) (size!146 (_ BitVec 32))))))

(declare-const arr!0 (array!204 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!204 A!296) (bvsge (size!146 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!146 arr!0))) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-145.tip

(declare-datatypes () ((Tree!11 (Leaf!10) (Node!15 (left!41 Tree!11) (value!70 Int) (right!43 Tree!11)))))

(define-fun-rec content!5 ((tree!0 Tree!11)) (Set Int) (ite (is-Leaf!10 tree!0) (as emptyset Int) (union (union (content!5 (left!41 tree!0)) (insert (as emptyset Int) (value!70 tree!0))) (content!5 (right!43 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!11)) Bool (ite (is-Leaf!10 tree!1) true (and (and (and (isBST!0 (left!41 tree!1)) (isBST!0 (right!43 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!41 tree!1))) (< x!84 (value!70 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!43 tree!1))) (< (value!70 tree!1) x!85))))))

(declare-const tree!2 Tree!11)

(declare-const value!2 Int)

(define-fun-rec insert!0 ((tree!2 Tree!11) (value!2 Int)) Tree!11 (assume (isBST!0 tree!2) (let ((res!60 (ite (is-Leaf!10 tree!2) (Node!15 Leaf!10 value!2 Leaf!10) (ite (< (value!70 tree!2) value!2) (Node!15 (left!41 tree!2) (value!70 tree!2) (insert!0 (right!43 tree!2) value!2)) (ite (> (value!70 tree!2) value!2) (Node!15 (insert!0 (left!41 tree!2) value!2) (value!70 tree!2) (right!43 tree!2)) (Node!15 (left!41 tree!2) (value!70 tree!2) (right!43 tree!2))))))) (assume (and (isBST!0 res!60) (= (content!5 res!60) (union (content!5 tree!2) (insert (as emptyset Int) value!2)))) res!60))))

(assert (not (=> (isBST!0 tree!2) (let ((res!378 (ite (is-Leaf!10 tree!2) (Node!15 Leaf!10 value!2 Leaf!10) (ite (< (value!70 tree!2) value!2) (Node!15 (left!41 tree!2) (value!70 tree!2) (insert!0 (right!43 tree!2) value!2)) (ite (> (value!70 tree!2) value!2) (Node!15 (insert!0 (left!41 tree!2) value!2) (value!70 tree!2) (right!43 tree!2)) (Node!15 (left!41 tree!2) (value!70 tree!2) (right!43 tree!2))))))) (and (isBST!0 res!378) (= (content!5 res!378) (union (content!5 tree!2) (insert (as emptyset Int) value!2))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-146.tip

(declare-datatypes () ((List!114 (Cons!159 (head!206 (_ BitVec 32)) (tail!212 List!114)) (Nil!159))))

(declare-datatypes () ((AbsQueue!41 (Queue!41 (front!48 List!114) (rear!47 List!114)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!41)) Bool (ite (and (is-Queue!41 queue!2) (is-Nil!159 (front!48 queue!2)) (is-Nil!159 (rear!47 queue!2))) true false))

(declare-const queue!8 AbsQueue!41)

(define-fun-rec size!2 ((list!0 List!114)) Int (let ((x$1!6 (ite (is-Nil!159 list!0) 0 (+ 1 (size!2 (tail!212 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!114)) (Set (_ BitVec 32)) (ite (is-Nil!159 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!206 l!21)) (content!4 (tail!212 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!114) (l2!10 List!114)) List!114 (let ((res!35 (ite (is-Nil!159 l1!12) l2!10 (Cons!159 (head!206 l1!12) (concat!0 (tail!212 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!114)) List!114 (let ((x$2!4 (ite (is-Nil!159 l!22) Nil!159 (concat!0 (reverse!1 (tail!212 l!22)) (Cons!159 (head!206 l!22) Nil!159))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!41)) Bool (>= (size!2 (front!48 queue!1)) (size!2 (rear!47 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!114) (rear!3 List!114)) AbsQueue!41 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!41 front!3 rear!3) (Queue!41 (concat!0 front!3 (reverse!1 rear!3)) Nil!159)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!41) (elem!1 (_ BitVec 32))) AbsQueue!41 (let ((x$4!1 (amortizedQueue!0 (front!48 queue!3) (Cons!159 elem!1 (rear!47 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!41)) (_ BitVec 32) (head!206 (front!48 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!41)) AbsQueue!41 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!212 (front!48 queue!4)) (rear!47 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (and (isAmortized!0 q4!0) (not (isEmpty!2 q4!0))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-147.tip

(declare-datatypes () ((Tree!13 (Leaf!12) (Node!17 (left!43 Tree!13) (value!73 Int) (right!45 Tree!13)))))

(define-fun-rec content!6 ((thiss!116 Tree!13)) (Set Int) (ite (is-Leaf!12 thiss!116) (as emptyset Int) (union (union (content!6 (left!43 thiss!116)) (insert (as emptyset Int) (value!73 thiss!116))) (content!6 (right!45 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!13)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!43 thiss!117))) (< x!86 (value!73 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!45 thiss!117))) (< (value!73 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!13)) Bool (ite (is-Node!17 thiss!115) (inv!9 (assume (is-Node!17 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!13 (ite (is-Node!17 thiss!115) (inv!9 (assume (is-Node!17 thiss!115) thiss!115)) true))

(assert (not (inv!41 Leaf!12)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-148.tip

(declare-datatypes () ((Tree!15 (Leaf!14) (Node!19 (left!45 Tree!15) (value!75 Int) (right!47 Tree!15)))))

(declare-const tree!3 Tree!15)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!15)) (Set Int) (ite (is-Leaf!14 thiss!116) (as emptyset Int) (union (union (content!6 (left!45 thiss!116)) (insert (as emptyset Int) (value!75 thiss!116))) (content!6 (right!47 thiss!116)))))

(define-fun-rec insert!1 ((tree!3 Tree!15) (value!4 Int)) Tree!15 (let ((res!61 (ite (is-Leaf!14 tree!3) (Node!19 Leaf!14 value!4 Leaf!14) (ite (< (value!75 tree!3) value!4) (Node!19 (left!45 tree!3) (value!75 tree!3) (insert!1 (right!47 tree!3) value!4)) (ite (> (value!75 tree!3) value!4) (Node!19 (insert!1 (left!45 tree!3) value!4) (value!75 tree!3) (right!47 tree!3)) (Node!19 (left!45 tree!3) (value!75 tree!3) (right!47 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(define-fun inv!9 ((thiss!117 Tree!15)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!45 thiss!117))) (< x!86 (value!75 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!47 thiss!117))) (< (value!75 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!15 (ite (is-Node!19 thiss!115) (inv!9 (assume (is-Node!19 thiss!115) thiss!115)) true))

(assert (not (let ((res!419 (ite (is-Leaf!14 tree!3) (Node!19 Leaf!14 value!4 Leaf!14) (ite (< (value!75 tree!3) value!4) (Node!19 (left!45 tree!3) (value!75 tree!3) (insert!1 (right!47 tree!3) value!4)) (ite (> (value!75 tree!3) value!4) (Node!19 (insert!1 (left!45 tree!3) value!4) (value!75 tree!3) (right!47 tree!3)) (Node!19 (left!45 tree!3) (value!75 tree!3) (right!47 tree!3))))))) (= (content!6 res!419) (union (content!6 tree!3) (insert (as emptyset Int) value!4))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-149.tip

(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!210 (array!211 (arr!106 (Array (_ BitVec 32) A!297)) (size!149 (_ BitVec 32))))))

(declare-const arr!0 (array!210 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!210 A!296) (bvsge (size!149 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!149 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-15.tip

(declare-datatypes () ((List!18 (Cons!27 (head!65 (_ BitVec 32)) (tail!71 List!18)) (Nil!27))))

(declare-datatypes () ((C!14 (C!15 (l!114 List!18)))))

(declare-const c!14 C!14)

(assert (not (is-Cons!27 (l!114 c!14))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-150.tip

(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!214 (array!215 (arr!108 (Array (_ BitVec 32) A!297)) (size!151 (_ BitVec 32))))))

(declare-const arr!0 (array!214 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!214 A!296) (bvsge (size!151 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!151 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!151 arr!0)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-151.tip

(declare-datatypes () ((List!116 (Cons!161 (head!208 (_ BitVec 32)) (tail!214 List!116)) (Nil!161))))

(declare-datatypes () ((AbsQueue!43 (Queue!43 (front!50 List!116) (rear!49 List!116)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!43)) Bool (ite (and (is-Queue!43 queue!2) (is-Nil!161 (front!50 queue!2)) (is-Nil!161 (rear!49 queue!2))) true false))

(declare-const queue!8 AbsQueue!43)

(define-fun-rec size!2 ((list!0 List!116)) Int (let ((x$1!6 (ite (is-Nil!161 list!0) 0 (+ 1 (size!2 (tail!214 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!116)) (Set (_ BitVec 32)) (ite (is-Nil!161 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!208 l!21)) (content!4 (tail!214 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!116) (l2!10 List!116)) List!116 (let ((res!35 (ite (is-Nil!161 l1!12) l2!10 (Cons!161 (head!208 l1!12) (concat!0 (tail!214 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!116)) List!116 (let ((x$2!4 (ite (is-Nil!161 l!22) Nil!161 (concat!0 (reverse!1 (tail!214 l!22)) (Cons!161 (head!208 l!22) Nil!161))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!43)) Bool (>= (size!2 (front!50 queue!1)) (size!2 (rear!49 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!116) (rear!3 List!116)) AbsQueue!43 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!43 front!3 rear!3) (Queue!43 (concat!0 front!3 (reverse!1 rear!3)) Nil!161)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!43) (elem!1 (_ BitVec 32))) AbsQueue!43 (let ((x$4!1 (amortizedQueue!0 (front!50 queue!3) (Cons!161 elem!1 (rear!49 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!43)) (_ BitVec 32) (head!208 (front!50 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!43)) AbsQueue!43 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!214 (front!50 queue!4)) (rear!49 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (let ((q5!0 (tail!8 q4!0))) (and (isAmortized!0 q5!0) (not (isEmpty!2 q5!0)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-152.tip

(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!218 (array!219 (arr!110 (Array (_ BitVec 32) A!297)) (size!153 (_ BitVec 32))))))

(declare-const arr!0 (array!218 (_ BitVec 32)))

(declare-const x!83 (_ BitVec 32))

(datatype-invariant (par (A!296) array!197 (array!218 A!296) (bvsge (size!153 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!153 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (let ((y!13 (assume (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!153 arr!0))) (select (arr!110 arr!0) i!22)))) (=> (and (not (= x!83 y!13)) (bvsge x!83 y!13)) (and (and (bvsle #b00000000000000000000000000000000 (bvadd i!22 #b00000000000000000000000000000001)) (bvsle (bvadd i!22 #b00000000000000000000000000000001) (bvadd hi!0 #b00000000000000000000000000000001))) (bvslt hi!0 (size!153 arr!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-153.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!122 (fun2!123 (f!627 (=> A1!271 A2!189 R!294)) (pre!447 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!122 A!41 A!41 A!41))))

(declare-const (par (A!41) (x!651 A!41)))

(declare-const (par (A!41) (x!652 A!41)))

(assert (par (A!41) (not (@ (f!627 (fun2!123 (pre!447 (fun2!123 (pre!447 (as f1!0 (fun2!122 A!41 A!41 A!41))) (lambda ((x!1244 A!41) (x!1245 A!41)) true))) (lambda ((x!1246 A!41) (x!1247 A!41)) true))) (as x!651 A!41) (as x!652 A!41)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-154.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!126 (fun2!127 (f!629 (=> A1!271 A2!189 R!294)) (pre!449 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!126 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!126 B!30 B!30 B!30))))

(declare-const (par (B!30) (x!653 B!30)))

(declare-const (par (B!30) (x!654 B!30)))

(assert (par (A!41 B!30) (not (=> (forall ((x!651 A!41)(x!652 A!41)) (@ (f!629 (fun2!127 (pre!449 (as f1!0 (fun2!126 A!41 A!41 A!41))) (lambda ((x!1254 A!41) (x!1255 A!41)) true))) x!651 x!652)) (@ (f!629 (fun2!127 (pre!449 (fun2!127 (pre!449 (as f2!1 (fun2!126 B!30 B!30 B!30))) (lambda ((x!1256 B!30) (x!1257 B!30)) true))) (lambda ((x!1258 B!30) (x!1259 B!30)) true))) (as x!653 B!30) (as x!654 B!30))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-155.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!132 (fun2!133 (f!632 (=> A1!271 A2!189 R!294)) (pre!452 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!132 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!132 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!132 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!632 f!31) (@ (f!632 f!31) x!76 y!8) z!9) (@ (f!632 f!31) x!76 (@ (f!632 f!31) y!8 z!9)))))))

(declare-datatypes (A0!9 A1!397) ((tuple2!12 (tuple2!13 (_1!6 A0!9) (_2!6 A1!397)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!12 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!12 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!632 (fun2!133 (pre!452 (as f1!0 (fun2!132 A!41 A!41 A!41))) (lambda ((x!1272 A!41) (x!1273 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!632 (fun2!133 (pre!452 (as f2!1 (fun2!132 B!30 B!30 B!30))) (lambda ((x!1274 B!30) (x!1275 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!132 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!132 B!30 B!30 B!30)))) (@ (f!632 (fun2!133 (pre!452 (fun2!133 (pre!452 (as f1!0 (fun2!132 A!41 A!41 A!41))) (lambda ((x!1276 A!41) (x!1277 A!41)) true))) (lambda ((x!1278 A!41) (x!1279 A!41)) true))) (_1!6 (as p1!0 (tuple2!12 A!41 B!30))) (_1!6 (as p2!0 (tuple2!12 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-156.tip

(declare-datatypes () ((Tree!17 (Leaf!16) (Node!21 (left!47 Tree!17) (value!77 Int) (right!49 Tree!17)))))

(define-fun-rec content!5 ((tree!0 Tree!17)) (Set Int) (ite (is-Leaf!16 tree!0) (as emptyset Int) (union (union (content!5 (left!47 tree!0)) (insert (as emptyset Int) (value!77 tree!0))) (content!5 (right!49 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!17)) Bool (ite (is-Leaf!16 tree!1) true (and (and (and (isBST!0 (left!47 tree!1)) (isBST!0 (right!49 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!47 tree!1))) (< x!84 (value!77 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!49 tree!1))) (< (value!77 tree!1) x!85))))))

(declare-const tree!2 Tree!17)

(assert (not (=> (isBST!0 tree!2) (or (is-Leaf!16 tree!2) (is-Node!21 tree!2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-157.tip

(declare-datatypes () ((Tree!19 (Leaf!18) (Node!23 (left!49 Tree!19) (value!79 Int) (right!51 Tree!19)))))

(declare-const tree!1 Tree!19)

(assert (not (or (is-Leaf!18 tree!1) (is-Node!23 tree!1))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-158.tip

(declare-datatypes () ((Tree!21 (Leaf!20) (Node!25 (left!51 Tree!21) (value!81 Int) (right!53 Tree!21)))))

(declare-const tree!0 Tree!21)

(assert (not (or (is-Leaf!20 tree!0) (is-Node!25 tree!0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-159.tip

(declare-datatypes () ((List!118 (Cons!163 (head!210 (_ BitVec 32)) (tail!216 List!118)) (Nil!163))))

(declare-datatypes () ((AbsQueue!45 (Queue!45 (front!52 List!118) (rear!51 List!118)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!45)) Bool (ite (and (is-Queue!45 queue!2) (is-Nil!163 (front!52 queue!2)) (is-Nil!163 (rear!51 queue!2))) true false))

(declare-const queue!8 AbsQueue!45)

(define-fun-rec size!2 ((list!0 List!118)) Int (let ((x$1!6 (ite (is-Nil!163 list!0) 0 (+ 1 (size!2 (tail!216 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!118)) (Set (_ BitVec 32)) (ite (is-Nil!163 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!210 l!21)) (content!4 (tail!216 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!118) (l2!10 List!118)) List!118 (let ((res!35 (ite (is-Nil!163 l1!12) l2!10 (Cons!163 (head!210 l1!12) (concat!0 (tail!216 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!118)) List!118 (let ((x$2!4 (ite (is-Nil!163 l!22) Nil!163 (concat!0 (reverse!1 (tail!216 l!22)) (Cons!163 (head!210 l!22) Nil!163))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!45)) Bool (>= (size!2 (front!52 queue!1)) (size!2 (rear!51 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!118) (rear!3 List!118)) AbsQueue!45 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!45 front!3 rear!3) (Queue!45 (concat!0 front!3 (reverse!1 rear!3)) Nil!163)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!45) (elem!1 (_ BitVec 32))) AbsQueue!45 (let ((x$4!1 (amortizedQueue!0 (front!52 queue!3) (Cons!163 elem!1 (rear!51 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!45)) (_ BitVec 32) (head!210 (front!52 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!45)) AbsQueue!45 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!216 (front!52 queue!4)) (rear!51 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (ite (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (let ((q5!0 (tail!8 q4!0))) (let ((e3prime!0 (front!5 q5!0))) (and (and (= e1!0 e1prime!0) (= e2!0 e2prime!0)) (= e3!0 e3prime!0)))))))))) true)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-16.tip

(declare-datatypes (A1!36 R!59) ((fun1!36 (fun1!37 (f!200 (=> A1!36 R!59)) (pre!103 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!13 (Positive!14 (i!77 Int)))))

(declare-const f!28 (fun1!36 Positive!13 Positive!13))

(datatype-invariant thiss!1 Positive!13 (> (i!77 thiss!1) 0))

(assert (not (=> (@ (f!200 (fun1!37 (pre!103 f!28) (lambda ((x!327 Positive!13)) true))) (Positive!14 1)) (@ (f!200 (fun1!37 (pre!103 f!28) (lambda ((x!328 Positive!13)) true))) (Positive!14 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-160.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!138 (fun2!139 (f!637 (=> A1!271 A2!189 R!294)) (pre!455 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!138 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!138 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!138 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!637 f!31) (@ (f!637 f!31) x!76 y!8) z!9) (@ (f!637 f!31) x!76 (@ (f!637 f!31) y!8 z!9)))))))

(declare-datatypes (A0!12 A1!402) ((tuple2!16 (tuple2!17 (_1!8 A0!12) (_2!8 A1!402)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!16 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!16 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!637 (fun2!139 (pre!455 (as f1!0 (fun2!138 A!41 A!41 A!41))) (lambda ((x!1314 A!41) (x!1315 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!637 (fun2!139 (pre!455 (as f2!1 (fun2!138 B!30 B!30 B!30))) (lambda ((x!1316 B!30) (x!1317 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!138 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!138 B!30 B!30 B!30))) (@ (f!637 (fun2!139 (pre!455 (as f1!0 (fun2!138 A!41 A!41 A!41))) (lambda ((x!1318 A!41) (x!1319 A!41)) true))) (_1!8 (as p1!0 (tuple2!16 A!41 B!30))) (_1!8 (as p2!0 (tuple2!16 A!41 B!30))))) (@ (f!637 (fun2!139 (pre!455 (fun2!139 (pre!455 (as f2!1 (fun2!138 B!30 B!30 B!30))) (lambda ((x!1320 B!30) (x!1321 B!30)) true))) (lambda ((x!1322 B!30) (x!1323 B!30)) true))) (_2!8 (as p1!0 (tuple2!16 A!41 B!30))) (_2!8 (as p2!0 (tuple2!16 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-161.tip

(declare-datatypes () ((Tree!23 (Leaf!22) (Node!27 (left!53 Tree!23) (value!83 Int) (right!55 Tree!23)))))

(declare-const tree!3 Tree!23)

(define-fun-rec content!6 ((thiss!116 Tree!23)) (Set Int) (ite (is-Leaf!22 thiss!116) (as emptyset Int) (union (union (content!6 (left!53 thiss!116)) (insert (as emptyset Int) (value!83 thiss!116))) (content!6 (right!55 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!23)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!53 thiss!117))) (< x!86 (value!83 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!55 thiss!117))) (< (value!83 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!23 (ite (is-Node!27 thiss!115) (inv!9 (assume (is-Node!27 thiss!115) thiss!115)) true))

(assert (not (or (is-Leaf!22 tree!3) (is-Node!27 tree!3))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-162.tip

(declare-datatypes () ((Tree!25 (Leaf!24) (Node!29 (left!55 Tree!25) (value!85 Int) (right!57 Tree!25)))))

(declare-const tree!3 Tree!25)

(define-fun-rec content!6 ((thiss!116 Tree!25)) (Set Int) (ite (is-Leaf!24 thiss!116) (as emptyset Int) (union (union (content!6 (left!55 thiss!116)) (insert (as emptyset Int) (value!85 thiss!116))) (content!6 (right!57 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!25)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!55 thiss!117))) (< x!86 (value!85 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!57 thiss!117))) (< (value!85 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!25)) Bool (ite (is-Node!29 thiss!115) (inv!9 (assume (is-Node!29 thiss!115) thiss!115)) true))

(declare-const value!4 Int)

(datatype-invariant thiss!115 Tree!25 (ite (is-Node!29 thiss!115) (inv!9 (assume (is-Node!29 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!24 tree!3) (inv!41 (Node!29 Leaf!24 value!4 Leaf!24)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-163.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!144 (fun2!145 (f!642 (=> A1!271 A2!189 R!294)) (pre!458 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!144 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!144 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!144 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!642 f!31) (@ (f!642 f!31) x!76 y!8) z!9) (@ (f!642 f!31) x!76 (@ (f!642 f!31) y!8 z!9)))))))

(declare-datatypes (A0!15 A1!407) ((tuple2!20 (tuple2!21 (_1!10 A0!15) (_2!10 A1!407)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!20 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!20 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1367 A!41) (x!1368 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!642 (fun2!145 (pre!458 (as f2!1 (fun2!144 B!30 B!30 B!30))) (lambda ((x!1372 B!30) (x!1373 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!144 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!144 B!30 B!30 B!30))) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1374 A!41) (x!1375 A!41)) true))) (_1!10 (as p1!0 (tuple2!20 A!41 B!30))) (_1!10 (as p2!0 (tuple2!20 A!41 B!30)))) (@ (f!642 (fun2!145 (pre!458 (as f2!1 (fun2!144 B!30 B!30 B!30))) (lambda ((x!1376 B!30) (x!1377 B!30)) true))) (_2!10 (as p1!0 (tuple2!20 A!41 B!30))) (_2!10 (as p2!0 (tuple2!20 A!41 B!30))))) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1378 A!41) (x!1379 A!41)) true))) (_1!10 (as p1!0 (tuple2!20 A!41 B!30))) (_1!10 (as p2!0 (tuple2!20 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-164.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!150 (fun2!151 (f!647 (=> A1!271 A2!189 R!294)) (pre!461 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!150 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!150 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!150 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!647 f!31) (@ (f!647 f!31) x!76 y!8) z!9) (@ (f!647 f!31) x!76 (@ (f!647 f!31) y!8 z!9)))))))

(declare-datatypes (A0!18 A1!412) ((tuple2!24 (tuple2!25 (_1!12 A0!18) (_2!12 A1!412)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!24 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!24 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!647 (fun2!151 (pre!461 (as f1!0 (fun2!150 A!41 A!41 A!41))) (lambda ((x!1411 A!41) (x!1412 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1413 B!30) (x!1414 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!150 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!150 B!30 B!30 B!30))) (@ (f!647 (fun2!151 (pre!461 (as f1!0 (fun2!150 A!41 A!41 A!41))) (lambda ((x!1415 A!41) (x!1416 A!41)) true))) (_1!12 (as p1!0 (tuple2!24 A!41 B!30))) (_1!12 (as p2!0 (tuple2!24 A!41 B!30)))) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1417 B!30) (x!1418 B!30)) true))) (_2!12 (as p1!0 (tuple2!24 A!41 B!30))) (_2!12 (as p2!0 (tuple2!24 A!41 B!30))))) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1419 B!30) (x!1420 B!30)) true))) (_2!12 (as p1!0 (tuple2!24 A!41 B!30))) (_2!12 (as p2!0 (tuple2!24 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-165.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!157 (fun2!158 (f!663 (=> A1!271 A2!189 R!294)) (pre!475 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!157 A!42 A!42 A!42))))

(assert (par (A!42) (not (=> (forall ((x!647 A!42)(x!648 A!42)) (@ (f!663 (fun2!158 (pre!475 (as f!34 (fun2!157 A!42 A!42 A!42))) (lambda ((x!1452 A!42) (x!1453 A!42)) true))) x!647 x!648)) (forall ((x!645 A!42)(x!646 A!42)) (@ (f!663 (fun2!158 (pre!475 (as f!34 (fun2!157 A!42 A!42 A!42))) (lambda ((x!1454 A!42) (x!1455 A!42)) true))) x!645 x!646))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-166.tip

(declare-const x!94 (_ BitVec 32))

(declare-const y!14 (_ BitVec 32))

(assert (not (let ((res!489 (bvxor (bvxor x!94 y!14) x!94))) (= res!489 y!14))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-167.tip

(declare-datatypes () ((Tree!27 (Leaf!26) (Node!31 (left!57 Tree!27) (value!88 Int) (right!59 Tree!27)))))

(declare-const tree!3 Tree!27)

(define-fun-rec content!6 ((thiss!116 Tree!27)) (Set Int) (ite (is-Leaf!26 thiss!116) (as emptyset Int) (union (union (content!6 (left!57 thiss!116)) (insert (as emptyset Int) (value!88 thiss!116))) (content!6 (right!59 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!27)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!57 thiss!117))) (< x!86 (value!88 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!59 thiss!117))) (< (value!88 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!27)) Bool (ite (is-Node!31 thiss!115) (inv!9 (assume (is-Node!31 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!27 (ite (is-Node!31 thiss!115) (inv!9 (assume (is-Node!31 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!26 tree!3) (inv!41 Leaf!26))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-168.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!161 (fun2!162 (f!665 (=> A1!271 A2!189 R!294)) (pre!477 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!161 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!161 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!665 f!32) x!77 y!9) (@ (f!665 f!32) y!9 x!77))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!665 (fun2!162 (pre!477 (as f!34 (fun2!161 A!42 A!42 A!42))) (lambda ((x!1473 A!42) (x!1474 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!161 A!42 A!42 A!42)))) (forall ((x!655 A!42)(x!656 A!42)) (@ (f!665 (fun2!162 (pre!477 (as f!34 (fun2!161 A!42 A!42 A!42))) (lambda ((x!1475 A!42) (x!1476 A!42)) true))) x!655 x!656))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-169.tip

(declare-datatypes () ((Tree!29 (Leaf!28) (Node!33 (left!59 Tree!29) (value!90 Int) (right!61 Tree!29)))))

(declare-const tree!3 Tree!29)

(define-fun-rec content!6 ((thiss!116 Tree!29)) (Set Int) (ite (is-Leaf!28 thiss!116) (as emptyset Int) (union (union (content!6 (left!59 thiss!116)) (insert (as emptyset Int) (value!90 thiss!116))) (content!6 (right!61 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!29)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!59 thiss!117))) (< x!86 (value!90 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!61 thiss!117))) (< (value!90 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!29)) Bool (ite (is-Node!33 thiss!115) (inv!9 (assume (is-Node!33 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!29 (ite (is-Node!33 thiss!115) (inv!9 (assume (is-Node!33 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!28 tree!3) (inv!41 Leaf!28))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-17.tip

(declare-datatypes () ((A!103 (Cons!30 (head!67 Int) (tail!73 A!103)) (Nil!30 (i!82 Int)))))

(declare-const thiss!8 A!103)

(define-fun inv!5 ((thiss!6 A!103)) Bool (>= (i!82 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!103)) Int (assume (or (is-Cons!30 thiss!5) (is-Nil!30 thiss!5)) (let ((i!14 (ite (is-Cons!30 thiss!5) (+ 1 (size!1 (tail!73 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!103)) Bool (ite (is-Nil!30 thiss!8) (inv!5 (assume (is-Nil!30 thiss!8) thiss!8)) (ite (is-Cons!30 thiss!8) (= (head!67 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!103 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (or (is-Cons!30 thiss!8) (is-Nil!30 thiss!8)) (is-Nil!30 thiss!8)) (is-Nil!30 thiss!8))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-170.tip

(declare-const x!89 (_ BitVec 32))

(assert (not (let ((res!483 (= (bvand x!89 #b00000000000000000000000000000001) #b00000000000000000000000000000000))) (= res!483 (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem x!89 #b00000000000000000000000000000010)) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-171.tip

(declare-datatypes () ((Tree!31 (Leaf!30) (Node!35 (left!61 Tree!31) (value!92 Int) (right!63 Tree!31)))))

(declare-const tree!3 Tree!31)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!31)) (Set Int) (ite (is-Leaf!30 thiss!116) (as emptyset Int) (union (union (content!6 (left!61 thiss!116)) (insert (as emptyset Int) (value!92 thiss!116))) (content!6 (right!63 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!31)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!61 thiss!117))) (< x!86 (value!92 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!63 thiss!117))) (< (value!92 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!31)) Bool (ite (is-Node!35 thiss!115) (inv!9 (assume (is-Node!35 thiss!115) thiss!115)) true))

(define-fun-rec insert!1 ((tree!3 Tree!31) (value!4 Int)) Tree!31 (let ((res!61 (ite (is-Leaf!30 tree!3) (Node!35 Leaf!30 value!4 Leaf!30) (ite (< (value!92 tree!3) value!4) (Node!35 (left!61 tree!3) (value!92 tree!3) (insert!1 (right!63 tree!3) value!4)) (ite (> (value!92 tree!3) value!4) (Node!35 (insert!1 (left!61 tree!3) value!4) (value!92 tree!3) (right!63 tree!3)) (Node!35 (left!61 tree!3) (value!92 tree!3) (right!63 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(datatype-invariant thiss!115 Tree!31 (ite (is-Node!35 thiss!115) (inv!9 (assume (is-Node!35 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!30 tree!3)) (is-Node!35 tree!3)) (let ((l!31 (left!61 tree!3))) (let ((v!16 (value!92 tree!3))) (let ((r!12 (right!63 tree!3))) (=> (< v!16 value!4) (inv!41 (Node!35 l!31 v!16 (insert!1 r!12 value!4))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-172.tip

(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-173.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!165 (fun2!166 (f!668 (=> A1!271 A2!189 R!294)) (pre!479 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!165 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!165 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!668 f!32) x!77 y!9) (@ (f!668 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!165 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!668 f!33) (@ (f!668 f!33) x!78 y!10) z!10) (@ (f!668 f!33) (@ (f!668 f!33) y!10 z!10) x!78))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!668 (fun2!166 (pre!479 (as f!34 (fun2!165 A!42 A!42 A!42))) (lambda ((x!1498 A!42) (x!1499 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!165 A!42 A!42 A!42))) (isRotate!0 (as f!34 (fun2!165 A!42 A!42 A!42)))) (forall ((x!649 A!42)(x!650 A!42)) (@ (f!668 (fun2!166 (pre!479 (as f!34 (fun2!165 A!42 A!42 A!42))) (lambda ((x!1500 A!42) (x!1501 A!42)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-174.tip

(declare-const x!90 (_ BitVec 32))

(assert (not (let ((b!959 (= (bvlshr x!90 #b00000000000000000000000000011111) #b00000000000000000000000000000001))) (= b!959 (bvslt x!90 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-175.tip

(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (or (and (bvsge x!101 #b00000000000000000000000000000000) (bvsle y!17 #b00000000000000000000000000000000)) (and (bvsle x!101 #b00000000000000000000000000000000) (bvsge y!17 #b00000000000000000000000000000000))) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-176.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!169 (fun2!170 (f!672 (=> A1!271 A2!189 R!294)) (pre!481 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!169 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!169 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!672 f!32) x!77 y!9) (@ (f!672 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!169 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!672 f!33) (@ (f!672 f!33) x!78 y!10) z!10) (@ (f!672 f!33) (@ (f!672 f!33) y!10 z!10) x!78))))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!169 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!672 f!31) (@ (f!672 f!31) x!76 y!8) z!9) (@ (f!672 f!31) x!76 (@ (f!672 f!31) y!8 z!9)))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!672 (fun2!170 (pre!481 (as f!34 (fun2!169 A!42 A!42 A!42))) (lambda ((x!1537 A!42) (x!1538 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!169 A!42 A!42 A!42))) (isRotate!0 (as f!34 (fun2!169 A!42 A!42 A!42)))) (isAssociative!0 (as f!34 (fun2!169 A!42 A!42 A!42)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-177.tip

(declare-const y!17 (_ BitVec 32))

(declare-const x!101 (_ BitVec 32))

(assert (not (=> (and (bvsgt y!17 #b00000000000000000000000000000000) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (bvsge x!101 #b00000000000000000000000000000000) (bvsle x!101 y!17)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-178.tip

(declare-const y!17 (_ BitVec 32))

(declare-const x!101 (_ BitVec 32))

(assert (not (=> (and (bvsgt y!17 #b00000000000000000000000000000000) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (bvsgt x!101 y!17) (bvsge x!101 #b00000000000000000000000000000000) (bvsle y!17 x!101)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-179.tip

(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (and (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 #b00000000000000000000000000000000)) (bvslt y!17 #b00000000000000000000000000000000) (bvslt x!101 #b00000000000000000000000000000000) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 x!101)) (bvsle x!101 #b00000000000000000000000000000000) (bvsle x!101 y!17)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-18.tip

(declare-datatypes (A1!50 R!72) ((fun1!50 (fun1!51 (f!209 (=> A1!50 R!72)) (pre!110 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!13 (~>!14 (f!212 (fun1!50 A!30 B!20)) (ens!7 (fun1!50 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!13 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!13 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!209 (fun1!51 (pre!110 (ens!7 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!209 (fun1!51 (pre!110 (f!212 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!209 (ens!7 thiss!2)) (@ (f!209 (f!212 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (and (forall ((x!56 B!27)) (@ (f!209 (fun1!51 (pre!110 (ens!7 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!337 B!27)) true))) x!56)) (@ (f!209 (fun1!51 (pre!110 (f!212 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!338 A!35)) true))) (as x!57 A!35))) (@ (f!209 (fun1!51 (pre!110 (f!212 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!339 A!35)) true))) (as x!57 A!35))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-180.tip

(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (and (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 #b00000000000000000000000000000000)) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt x!101 y!17)) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 x!101)) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvsgt x!101 y!17))) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-181.tip

(assert (not (and (bvsge #b00000000000000000000000000000101 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000101 #b00000000000000000000000000100000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-182.tip

(declare-datatypes () ((Tree!33 (Leaf!32) (Node!37 (left!63 Tree!33) (value!94 Int) (right!65 Tree!33)))))

(declare-const tree!3 Tree!33)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!33)) (Set Int) (ite (is-Leaf!32 thiss!116) (as emptyset Int) (union (union (content!6 (left!63 thiss!116)) (insert (as emptyset Int) (value!94 thiss!116))) (content!6 (right!65 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!33)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!63 thiss!117))) (< x!86 (value!94 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!65 thiss!117))) (< (value!94 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!33)) Bool (ite (is-Node!37 thiss!115) (inv!9 (assume (is-Node!37 thiss!115) thiss!115)) true))

(define-fun-rec insert!1 ((tree!3 Tree!33) (value!4 Int)) Tree!33 (let ((res!61 (ite (is-Leaf!32 tree!3) (Node!37 Leaf!32 value!4 Leaf!32) (ite (< (value!94 tree!3) value!4) (Node!37 (left!63 tree!3) (value!94 tree!3) (insert!1 (right!65 tree!3) value!4)) (ite (> (value!94 tree!3) value!4) (Node!37 (insert!1 (left!63 tree!3) value!4) (value!94 tree!3) (right!65 tree!3)) (Node!37 (left!63 tree!3) (value!94 tree!3) (right!65 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(datatype-invariant thiss!115 Tree!33 (ite (is-Node!37 thiss!115) (inv!9 (assume (is-Node!37 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!32 tree!3)) (is-Node!37 tree!3)) (let ((l!31 (left!63 tree!3))) (let ((v!16 (value!94 tree!3))) (let ((r!12 (right!65 tree!3))) (=> (and (>= v!16 value!4) (> v!16 value!4)) (inv!41 (Node!37 (insert!1 l!31 value!4) v!16 r!12)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-183.tip

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (let ((x$2!38 (isBitNSet!0 #b11111111111111111111111111011111 #b00000000000000000000000000000101))) (= x$2!38 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-184.tip

(define-fun rightPropagateRightmostOne!0 ((x!97 (_ BitVec 32))) (_ BitVec 32) (bvor x!97 (bvsub x!97 #b00000000000000000000000000000001)))

(declare-const x!98 (_ BitVec 32))

(assert (not (let ((y!15 (rightPropagateRightmostOne!0 x!98))) (= y!15 (rightPropagateRightmostOne!0 y!15)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-185.tip

(declare-const indexFromLeft!0 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000)) (and (bvsge (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000000000) (bvslt (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-186.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!173 (fun2!174 (f!677 (=> A1!271 A2!189 R!294)) (pre!483 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!173 A!42 A!42 A!42))))

(declare-const (par (A!42) (x!647 A!42)))

(declare-const (par (A!42) (x!648 A!42)))

(assert (par (A!42) (not (@ (f!677 (fun2!174 (pre!483 (fun2!174 (pre!483 (as f!34 (fun2!173 A!42 A!42 A!42))) (lambda ((x!1579 A!42) (x!1580 A!42)) true))) (lambda ((x!1581 A!42) (x!1582 A!42)) true))) (as x!647 A!42) (as x!648 A!42)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-187.tip

(declare-const indexFromLeft!0 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!95 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000) (bitAt!0 x!95 (bvsub #b00000000000000000000000000011111 indexFromLeft!0))) (and (bvsge (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000000000) (bvslt (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-188.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!177 (fun2!178 (f!679 (=> A1!271 A2!189 R!294)) (pre!485 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!177 Int Int Int))

(assert (not (=> (forall ((x!657 Int)(x!658 Int)) (@ (f!679 (fun2!178 (pre!485 f!35) (lambda ((x!1595 Int) (x!1596 Int)) true))) x!657 x!658)) (forall ((x!645 Int)(x!646 Int)) (@ (f!679 (fun2!178 (pre!485 f!35) (lambda ((x!1597 Int) (x!1598 Int)) true))) x!645 x!646)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-189.tip

(declare-const indexFromLeft!0 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!95 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000) (not (bitAt!0 x!95 (bvsub #b00000000000000000000000000011111 indexFromLeft!0))) (not (= indexFromLeft!0 #b00000000000000000000000000000000))) (and (bvsle #b00000000000000000000000000000000 (bvsub indexFromLeft!0 #b00000000000000000000000000000001)) (bvslt (bvsub indexFromLeft!0 #b00000000000000000000000000000001) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-19.tip

(declare-datatypes (A1!36 R!59) ((fun1!56 (fun1!57 (f!214 (=> A1!36 R!59)) (pre!113 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!17 (Positive!18 (i!85 Int)))))

(declare-const f!28 (fun1!56 Positive!17 Positive!17))

(define-fun inv!2 ((thiss!1 Positive!17)) Bool (> (i!85 thiss!1) 0))

(datatype-invariant thiss!1 Positive!17 (> (i!85 thiss!1) 0))

(assert (not (=> (@ (f!214 (fun1!57 (pre!113 f!28) (lambda ((x!341 Positive!17)) true))) (Positive!18 1)) (inv!2 (Positive!18 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-190.tip

(declare-const n!8 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-191.tip

(declare-datatypes () ((Tree!35 (Leaf!34) (Node!39 (left!65 Tree!35) (value!96 Int) (right!67 Tree!35)))))

(declare-const tree!3 Tree!35)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!35)) (Set Int) (ite (is-Leaf!34 thiss!116) (as emptyset Int) (union (union (content!6 (left!65 thiss!116)) (insert (as emptyset Int) (value!96 thiss!116))) (content!6 (right!67 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!35)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!65 thiss!117))) (< x!86 (value!96 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!67 thiss!117))) (< (value!96 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!35)) Bool (ite (is-Node!39 thiss!115) (inv!9 (assume (is-Node!39 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!35 (ite (is-Node!39 thiss!115) (inv!9 (assume (is-Node!39 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!34 tree!3)) (is-Node!39 tree!3)) (let ((l!31 (left!65 tree!3))) (let ((v!16 (value!96 tree!3))) (let ((r!12 (right!67 tree!3))) (=> (and (>= v!16 value!4) (<= v!16 value!4)) (inv!41 (Node!39 l!31 v!16 r!12)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-192.tip

(declare-datatypes () ((Tree!37 (Leaf!36) (Node!41 (left!67 Tree!37) (value!98 Int) (right!69 Tree!37)))))

(declare-const thiss!115 Tree!37)

(define-fun-rec content!6 ((thiss!116 Tree!37)) (Set Int) (ite (is-Leaf!36 thiss!116) (as emptyset Int) (union (union (content!6 (left!67 thiss!116)) (insert (as emptyset Int) (value!98 thiss!116))) (content!6 (right!69 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!37)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!67 thiss!117))) (< x!86 (value!98 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!69 thiss!117))) (< (value!98 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!37 (ite (is-Node!41 thiss!115) (inv!9 (assume (is-Node!41 thiss!115) thiss!115)) true))

(assert (not (=> (is-Node!41 thiss!115) (is-Node!41 thiss!115))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-193.tip

(declare-const n!8 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(declare-const x!93 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000) (not (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000))) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-194.tip

(declare-datatypes () ((Tree!39 (Leaf!38) (Node!43 (left!69 Tree!39) (value!101 Int) (right!71 Tree!39)))))

(declare-const thiss!116 Tree!39)

(define-fun-rec content!6 ((thiss!116 Tree!39)) (Set Int) (ite (is-Leaf!38 thiss!116) (as emptyset Int) (union (union (content!6 (left!69 thiss!116)) (insert (as emptyset Int) (value!101 thiss!116))) (content!6 (right!71 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!39)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!69 thiss!117))) (< x!86 (value!101 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!71 thiss!117))) (< (value!101 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!39 (ite (is-Node!43 thiss!115) (inv!9 (assume (is-Node!43 thiss!115) thiss!115)) true))

(assert (not (or (is-Leaf!38 thiss!116) (is-Node!43 thiss!116))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-195.tip

(declare-const b!25 Bool)

(declare-const d!2 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (let ((t!124 (ite b!25 d!2 false))) (let ((r!13 t!124)) (let ((res!66 (assume (= x!1594 #b00000000000000000000000000000010) r!13))) (=> (= res!66 (and b!25 d!2)) (or (= (bvand (toInt!0 b!25) (toInt!0 d!2)) #b00000000000000000000000000000000) (= (bvand (toInt!0 b!25) (toInt!0 d!2)) #b00000000000000000000000000000001)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-196.tip

(declare-const n!8 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(declare-const x!93 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000) (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000)) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-197.tip

(assert (not (not (= #b00000000000000000000000000001010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-198.tip

(assert (not (not (= 10 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-199.tip

(declare-const n!8 (_ BitVec 32))

(declare-const x!93 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)) (let ((res!487 (bvxor x!93 (bvshl #b00000000000000000000000000000001 n!8)))) (ite (not (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000)) (= (isBitNSet!0 res!487 n!8) #b00000000000000000000000000000000) (not (= (isBitNSet!0 res!487 n!8) #b00000000000000000000000000000000)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-2.tip

(declare-datatypes () ((Pos!1 (Pos!2 (i!52 Int)))))

(declare-const p!23 Pos!1)

(datatype-invariant thiss!0 Pos!1 (> (i!52 thiss!0) 0))

(assert (not (> (i!52 (Pos!2 (+ (i!52 p!23) 1))) 0)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-20.tip

(declare-datatypes (A1!50 R!72) ((fun1!66 (fun1!67 (f!222 (=> A1!50 R!72)) (pre!118 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!17 (~>!18 (f!225 (fun1!66 A!30 B!20)) (ens!9 (fun1!66 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!17 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!17 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!222 (fun1!67 (pre!118 (ens!9 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!222 (fun1!67 (pre!118 (f!225 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!222 (ens!9 thiss!2)) (@ (f!222 (f!225 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (and (forall ((x!56 B!27)) (@ (f!222 (fun1!67 (pre!118 (ens!9 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!349 B!27)) true))) x!56)) (@ (f!222 (fun1!67 (pre!118 (f!225 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!350 A!35)) true))) (as x!57 A!35))) (@ (f!222 (fun1!67 (pre!118 (ens!9 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!351 B!27)) true))) (@ (f!222 (f!225 (as thiss!2 (~>!17 A!35 B!27)))) (as x!57 A!35)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-200.tip

(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (= x!1601 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-201.tip

(declare-const b!26 Bool)

(declare-const d!3 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (let ((t!125 (ite b!26 true d!3))) (let ((r!14 t!125)) (let ((res!537 (assume (= x!1601 #b00000000000000000000000000000010) r!14))) (and (= res!537 (or b!26 d!3)) (= res!537 (toBool!0 (bvor (toInt!0 b!26) (toInt!0 d!3)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-202.tip

(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (= x!1594 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-203.tip

(declare-const y!19 (_ BitVec 32))

(assert (not (=> (not (= y!19 #b00000000000000000000000000000000)) (not (= y!19 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-204.tip

(declare-const b!25 Bool)

(declare-const d!2 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (let ((t!124 (ite b!25 d!2 false))) (let ((r!13 t!124)) (let ((res!536 (assume (= x!1594 #b00000000000000000000000000000010) r!13))) (and (= res!536 (and b!25 d!2)) (= res!536 (toBool!0 (bvand (toInt!0 b!25) (toInt!0 d!2)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-205.tip

(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (and (bvsge i!23 #b00000000000000000000000000000000) (bvslt i!23 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-206.tip

(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (and (bvsge (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)) #b00000000000000000000000000000000) (bvslt (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-207.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-208.tip

(declare-const b!27 Bool)

(declare-const d!4 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (let ((r!15 (not (= b!27 d!4)))) (let ((res!68 (assume (= x!1591 #b00000000000000000000000000000010) r!15))) (=> (= res!68 (not (= b!27 d!4))) (or (= (bvxor (toInt!0 b!27) (toInt!0 d!4)) #b00000000000000000000000000000000) (= (bvxor (toInt!0 b!27) (toInt!0 d!4)) #b00000000000000000000000000000001))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-209.tip

(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!99 (_ BitVec 32))

(declare-const y!16 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (let ((isOk!0 (= (bitAt!0 x!99 i!23) (bitAt!0 y!16 (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)))))) (=> (and (not (= i!23 #b00000000000000000000000000000000)) isOk!0) (and (and (and (bvsle #b00000000000000000000000000000000 (bvsub i!23 #b00000000000000000000000000000001)) (bvslt (bvsub i!23 #b00000000000000000000000000000001) #b00000000000000000000000000100000)) (bvsle #b00000000000000000000000000000000 n!9)) (bvslt n!9 #b00000000000000000000000000100000)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-21.tip

(declare-datatypes () ((A!111 (Cons!32 (head!69 Int) (tail!75 A!111)) (Nil!32 (i!90 Int)))))

(declare-const thiss!8 A!111)

(define-fun inv!5 ((thiss!6 A!111)) Bool (>= (i!90 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!111)) Int (assume (or (is-Cons!32 thiss!5) (is-Nil!32 thiss!5)) (let ((i!14 (ite (is-Cons!32 thiss!5) (+ 1 (size!1 (tail!75 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!111)) Bool (ite (is-Nil!32 thiss!8) (inv!5 (assume (is-Nil!32 thiss!8) thiss!8)) (ite (is-Cons!32 thiss!8) (= (head!69 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!111 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (is-Cons!32 thiss!8) (not (is-Nil!32 thiss!8))) (or (is-Cons!32 thiss!8) (is-Nil!32 thiss!8)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-210.tip

(declare-const b!26 Bool)

(declare-const d!3 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (let ((t!125 (ite b!26 true d!3))) (let ((r!14 t!125)) (let ((res!67 (assume (= x!1601 #b00000000000000000000000000000010) r!14))) (=> (= res!67 (or b!26 d!3)) (or (= (bvor (toInt!0 b!26) (toInt!0 d!3)) #b00000000000000000000000000000000) (= (bvor (toInt!0 b!26) (toInt!0 d!3)) #b00000000000000000000000000000001)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-211.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-212.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-213.tip

(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-214.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-215.tip

(declare-const b!32 (_ BitVec 8))

(declare-const c!15 (_ BitVec 8))

(assert (not (let ((res!570 (bvadd ((_ sign_extend 24) b!32) ((_ sign_extend 24) c!15)))) (and (bvsle #b11111111111111111111111100000000 res!570) (bvsle res!570 #b00000000000000000000000011111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-216.tip

(declare-const n!7 (_ BitVec 32))

(assert (not (=> (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)) (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-217.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-218.tip

(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (= x!1591 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-219.tip

(declare-const i!24 (_ BitVec 32))

(assert (not (bvslt ((_ sign_extend 24) ((_ extract 7 0) i!24)) #b00000000000000000000000010000000)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-22.tip

(declare-datatypes () ((A!117 (Cons!36 (head!73 Int) (tail!79 A!117)) (Nil!36 (i!92 Int)))))

(declare-const thiss!5 A!117)

(define-fun inv!5 ((thiss!6 A!117)) Bool (>= (i!92 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!117)) Int (assume (or (is-Cons!36 thiss!5) (is-Nil!36 thiss!5)) (let ((i!14 (ite (is-Cons!36 thiss!5) (+ 1 (size!1 (tail!79 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!117)) Bool (ite (is-Nil!36 thiss!8) (inv!5 (assume (is-Nil!36 thiss!8) thiss!8)) (ite (is-Cons!36 thiss!8) (= (head!73 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!117 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (or (is-Cons!36 thiss!5) (is-Nil!36 thiss!5)) (is-Cons!36 thiss!5)) (let ((h!47 (head!73 thiss!5))) (let ((t!54 (tail!79 thiss!5))) (or (is-Cons!36 t!54) (is-Nil!36 t!54)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-220.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-221.tip

(declare-const b!27 Bool)

(declare-const d!4 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (let ((r!15 (not (= b!27 d!4)))) (let ((res!538 (assume (= x!1591 #b00000000000000000000000000000010) r!15))) (and (= res!538 (not (= b!27 d!4))) (= res!538 (toBool!0 (bvxor (toInt!0 b!27) (toInt!0 d!4))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-222.tip

(declare-const n!7 (_ BitVec 32))

(declare-const x!92 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (=> (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)) (let ((res!485 (bvor x!92 (bvshl #b00000000000000000000000000000001 n!7)))) (not (= (isBitNSet!0 res!485 n!7) #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-223.tip

(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (= (bvneg (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv x!110 #b00000000000000000000000000000010))) (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvneg x!110) #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-224.tip

(declare-const b!31 (_ BitVec 8))

(assert (not (=> (and (bvsge ((_ sign_extend 24) b!31) #b11111111111111111111111110000000) (bvsle ((_ sign_extend 24) b!31) #b00000000000000000000000001111111)) (bvslt ((_ sign_extend 24) b!31) #b00000000000000000000000010000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-225.tip

(assert (not (and (bvsge #b00000000000000000000000000000011 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000011 #b00000000000000000000000000100000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-226.tip

(declare-const b!31 (_ BitVec 8))

(assert (not (and (bvsge ((_ sign_extend 24) b!31) #b11111111111111111111111110000000) (bvsle ((_ sign_extend 24) b!31) #b00000000000000000000000001111111))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-227.tip

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (let ((x$1!84 (isBitNSet!0 #b00000000000000000000000001111010 #b00000000000000000000000000000011))) (not (= x$1!84 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-228.tip

(assert (not (let ((b!29 #b01111111)) (not (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem ((_ sign_extend 24) b!29) #b00000000000000000000000000000010)) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-229.tip

(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-23.tip

(declare-datatypes () ((A!119 (Cons!38 (head!75 Int) (tail!81 A!119)) (Nil!38 (i!95 Int)))))

(declare-const a!18 A!119)

(define-fun inv!5 ((thiss!6 A!119)) Bool (>= (i!95 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!119)) Int (assume (or (is-Cons!38 thiss!5) (is-Nil!38 thiss!5)) (let ((i!14 (ite (is-Cons!38 thiss!5) (+ 1 (size!1 (tail!81 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!119)) Bool (ite (is-Nil!38 thiss!8) (inv!5 (assume (is-Nil!38 thiss!8) thiss!8)) (ite (is-Cons!38 thiss!8) (= (head!75 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!119 (inv!4 (assume true thiss!3)))

(assert (not (or (is-Cons!38 a!18) (is-Nil!38 a!18))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-230.tip

(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-231.tip

(define-fun test!6 ((b!30 (_ BitVec 8))) (_ BitVec 32) (ite (bvsgt ((_ sign_extend 24) b!30) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001))

(assert (not (let ((b!29 #b01111111)) (= (test!6 b!29) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-232.tip

(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-233.tip

(declare-const x!111 (_ BitVec 32))

(assert (not (= (bvneg (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv x!111 #b00000000000000000000000000000010))) (assume (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000)) (bvsdiv x!111 #b11111111111111111111111111111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-234.tip

(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-235.tip

(declare-datatypes (R!501) ((fun0!36 (fun0!37 (f!758 (=> R!501)) (pre!564 (=> Bool))))))

(assert (not (and (@ (f!758 (fun0!37 (pre!564 (fun0!37 (lambda () #b00000000000000000000000000000001) (lambda () true))) (lambda () true)))) (@ (f!758 (fun0!37 (pre!564 (fun0!37 (lambda () #b00000000000000000000000000000010) (lambda () true))) (lambda () true)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-236.tip

(declare-datatypes () ((A!374 (B!166 (size!176 (_ BitVec 32))) (C!21))))

(declare-const a!35 A!374)

(assert (not (or (is-C!21 a!35) (is-B!166 a!35))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-237.tip

(declare-const x!115 Int)

(assert (not (let ((x$1!86 (choose y!20 Int (let ((z!11 (+ x!115 2))) (= z!11 y!20))))) (= x$1!86 (+ x!115 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-238.tip

(assert (not (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-239.tip

(declare-datatypes (A1!517 R!537) ((fun1!213 (fun1!214 (f!792 (=> A1!517 R!537)) (pre!598 (=> A1!517 Bool))))))

(declare-datatypes (T!0) ((List!121 (Cons!179 (h!79 T!0) (t!127 (List!121 T!0))) (Nil!179))))

(declare-datatypes () ((Client!2 (Client!3 (f!794 (fun1!213 (_ BitVec 32) (List!121 (_ BitVec 32))))))))

(declare-const thiss!156 Client!2)

(declare-const x!1646 (_ BitVec 32))

(datatype-invariant thiss!156 Client!2 (forall ((x!1646 (_ BitVec 32))) (@ (f!792 (fun1!214 (pre!598 (f!794 thiss!156)) (lambda ((x!1650 (_ BitVec 32))) true))) x!1646)))

(assert (not (@ (f!792 (fun1!214 (pre!598 (fun1!214 (pre!598 (f!794 thiss!156)) (lambda ((x!1652 (_ BitVec 32))) true))) (lambda ((x!1653 (_ BitVec 32))) true))) x!1646)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-24.tip

(declare-datatypes (T!0) ((List!21 (Cons!39 (h!65 T!0) (t!98 (List!21 T!0))) (Nil!39))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!21 T!29))) (Set T!29) (ite (is-Nil!39 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!65 thiss!4)) (content!0 (t!98 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!21 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!39 thiss!10) (or (= (h!65 thiss!10) v!0) (contains!0 (t!98 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!21 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!76 (fun1!77 (f!231 (=> A1!50 R!72)) (pre!123 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!21 (~>!22 (f!234 (fun1!76 A!30 B!20)) (ens!11 (fun1!76 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!21 A!36 B!28))) (fun1!76 A!36 Bool) (fun1!77 (pre!123 (f!234 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!21 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!21 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!231 (fun1!77 (pre!123 (ens!11 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!231 (fun1!77 (pre!123 (f!234 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!231 (ens!11 thiss!2)) (@ (f!231 (f!234 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (and (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!21 A!31)) x!60) (@ (f!231 (pre!0 (as f!27 (~>!21 A!31 B!21)))) x!60))) (is-Cons!39 (as l!19 (List!21 A!31)))) (let ((x!61 (h!65 (as l!19 (List!21 A!31))))) (let ((xs!22 (t!98 (as l!19 (List!21 A!31))))) (@ (f!231 (fun1!77 (pre!123 (f!234 (as f!27 (~>!21 A!31 B!21)))) (lambda ((x!371 A!31)) true))) x!61)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-240.tip

(declare-datatypes () ((List!122 (Cons!180 (head!225 (_ BitVec 32)) (tail!231 List!122)) (Nil!180))))

(declare-const l!33 List!122)

(assert (not (or (is-Nil!180 l!33) (is-Cons!180 l!33))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-241.tip

(declare-datatypes () ((A!382 (B!168 (size!181 (_ BitVec 32))) (C!23))))

(declare-const a!36 A!382)

(assert (not (or (is-C!23 a!36) (is-B!168 a!36))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-242.tip

(declare-const x!115 Int)

(assert (not (exists ((y!20 Int)) (not (not (let ((z!11 (+ x!115 2))) (= z!11 y!20)))))))

(check-sat)

AbstractRefinementMap.scala-243.tip

(declare-datatypes (T!0) ((List!125 (Cons!183 (h!81 T!0) (t!129 (List!125 T!0))) (Nil!183))))

(define-fun-rec (par (T!181) (size!0 ((thiss!151 (List!125 T!181))) Int (let ((x$1!0 (ite (is-Nil!183 thiss!151) 0 (+ 1 (size!0 (t!129 thiss!151)))))) (assume (>= x$1!0 0) x$1!0)))))

(declare-datatypes (A1!517 R!537) ((fun1!219 (fun1!220 (f!797 (=> A1!517 R!537)) (pre!601 (=> A1!517 Bool))))))

(declare-datatypes () ((Client!6 (Client!7 (f!799 (fun1!219 (_ BitVec 32) (List!125 (_ BitVec 32))))))))

(define-fun client!0 () Client!6 (Client!7 (fun1!220 (lambda ((x!117 (_ BitVec 32))) (Cons!183 #b00000000000000000000000000000001 (as Nil!183 (List!125 (_ BitVec 32))))) (lambda ((x!1651 (_ BitVec 32))) true))))

(datatype-invariant thiss!156 Client!6 (forall ((x!1646 (_ BitVec 32))) (@ (f!797 (fun1!220 (pre!601 (f!799 thiss!156)) (lambda ((x!1650 (_ BitVec 32))) true))) x!1646)))

(assert (not (not (= (size!0 (@ (f!797 (f!799 client!0)) #b00000000000000000000000000000000)) 0))))

(check-sat)

AbstractRefinementMap.scala-244.tip

(declare-datatypes (R!501) ((fun0!41 (fun0!42 (f!800 (=> R!501)) (pre!603 (=> Bool))))))

(define-fun add!0 ((a!34 (fun0!41 (_ BitVec 32))) (b!33 (fun0!41 (_ BitVec 32)))) (_ BitVec 32) (bvadd (@ (f!800 a!34)) (@ (f!800 b!33))))

(assert (not (let ((x$1!85 (add!0 (fun0!42 (lambda () #b00000000000000000000000000000001) (lambda () true)) (fun0!42 (lambda () #b00000000000000000000000000000010) (lambda () true))))) (= x$1!85 #b00000000000000000000000000000011))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-245.tip

(declare-const x!112 (_ BitVec 32))

(assert (not (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem x!112 #b00000000000000000000000000000010)) (assume (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000)) (bvsrem x!112 #b11111111111111111111111111111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-246.tip

(declare-const i!27 Int)

(assert (not (=> (and (>= i!27 0) (> i!27 0)) (>= (- i!27 1) 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-247.tip

(declare-datatypes (R!501) ((fun0!45 (fun0!46 (f!804 (=> R!501)) (pre!605 (=> Bool))))))

(declare-const a!34 (fun0!45 (_ BitVec 32)))

(declare-const b!33 (fun0!45 (_ BitVec 32)))

(assert (not (=> (@ (f!804 (fun0!46 (pre!605 a!34) (lambda () true)))) (@ (f!804 (fun0!46 (pre!605 (fun0!46 (pre!605 b!33) (lambda () true))) (lambda () true)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-248.tip

(declare-const i!27 Int)

(declare-datatypes () ((List!128 (Cons!186 (head!227 (_ BitVec 32)) (tail!233 List!128)) (Nil!186))))

(define-fun-rec size!12 ((l!32 List!128)) Int (let ((res!80 (ite (is-Nil!186 l!32) 0 (+ 1 (size!12 (tail!233 l!32)))))) (assume (>= res!80 0) res!80)))

(define-fun-rec createListOfSize!0 ((i!25 Int)) List!128 (assume (>= i!25 0) (let ((x$1!19 (ite (= i!25 0) Nil!186 (Cons!186 #b00000000000000000000000000000000 (createListOfSize!0 (- i!25 1)))))) (assume (= (size!12 x$1!19) i!25) x$1!19))))

(define-fun listOfSize!0 ((i!26 Int)) List!128 (assume (>= i!26 0) (let ((x$2!7 (ite (= i!26 0) Nil!186 (assume (= (size!12 (createListOfSize!0 i!26)) i!26) (choose res!81 List!128 (= (size!12 res!81) i!26)))))) (assume (= (size!12 x$2!7) i!26) x$2!7))))

(assert (not (=> (>= i!27 0) (let ((x$3!17 (ite (> i!27 0) (Cons!186 #b00000000000000000000000000000000 (listOfSize!0 (- i!27 1))) Nil!186))) (= (size!12 x$3!17) i!27)))))

AbstractRefinementMap.scala-249.tip

(declare-datatypes (A1!541 R!567) ((fun1!226 (fun1!227 (f!820 (=> A1!541 R!567)) (pre!619 (=> A1!541 Bool))))))

(define-fun addX!0 ((x!118 (_ BitVec 32))) (fun1!226 (_ BitVec 32) (_ BitVec 32)) (fun1!227 (lambda ((a!37 (_ BitVec 32))) (bvadd a!37 x!118)) (lambda ((a!142 (_ BitVec 32))) true)))

(assert (not (let ((add1!0 (addX!0 #b00000000000000000000000000000001))) (let ((add2!0 (addX!0 #b00000000000000000000000000000010))) (= (@ (f!820 add1!0) (@ (f!820 add2!0) #b00000000000000000000000000000001)) #b00000000000000000000000000000100)))))

AbstractRefinementMap.scala-25.tip

(declare-datatypes () ((A!121 (Cons!41 (head!77 Int) (tail!83 A!121)) (Nil!41 (i!97 Int)))))

(declare-const thiss!5 A!121)

(define-fun-rec size!1 ((thiss!5 A!121)) Int (assume (or (is-Cons!41 thiss!5) (is-Nil!41 thiss!5)) (let ((i!14 (ite (is-Cons!41 thiss!5) (+ 1 (size!1 (tail!83 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!5 ((thiss!6 A!121)) Bool (>= (i!97 thiss!6) 0))

(define-fun inv!4 ((thiss!8 A!121)) Bool (ite (is-Nil!41 thiss!8) (inv!5 (assume (is-Nil!41 thiss!8) thiss!8)) (ite (is-Cons!41 thiss!8) (= (head!77 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!121 (inv!4 (assume true thiss!3)))

(assert (not (=> (or (is-Cons!41 thiss!5) (is-Nil!41 thiss!5)) (let ((i!45 (ite (is-Cons!41 thiss!5) (+ 1 (size!1 (tail!83 thiss!5))) 0))) (>= i!45 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-250.tip

(declare-datatypes (R!501) ((fun0!50 (fun0!51 (f!822 (=> R!501)) (pre!620 (=> Bool))))))

(declare-const a!34 (fun0!50 (_ BitVec 32)))

(declare-const b!33 (fun0!50 (_ BitVec 32)))

AbstractRefinementMap.scala-251.tip

(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

AbstractRefinementMap.scala-252.tip

(declare-datatypes (R!501) ((fun0!52 (fun0!53 (f!824 (=> R!501)) (pre!622 (=> Bool))))))

(declare-const a!34 (fun0!52 (_ BitVec 32)))

(assert (not (@ (f!824 (fun0!53 (pre!622 (fun0!53 (pre!622 a!34) (lambda () true))) (lambda () true))))))

AbstractRefinementMap.scala-26.tip

(declare-datatypes () ((A!125 (Cons!43 (head!79 Int) (tail!85 A!125)) (Nil!43 (i!99 Int)))))

(declare-const thiss!3 A!125)

(define-fun inv!5 ((thiss!6 A!125)) Bool (>= (i!99 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!125)) Int (assume (or (is-Cons!43 thiss!5) (is-Nil!43 thiss!5)) (let ((i!14 (ite (is-Cons!43 thiss!5) (+ 1 (size!1 (tail!85 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!125)) Bool (ite (is-Nil!43 thiss!8) (inv!5 (assume (is-Nil!43 thiss!8) thiss!8)) (ite (is-Cons!43 thiss!8) (= (head!79 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!125 (inv!4 (assume true thiss!3)))

(assert (not (or (is-Cons!43 (assume true thiss!3)) (is-Nil!43 (assume true thiss!3)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-27.tip

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-28.tip

(declare-datatypes (T!0) ((List!24 (Cons!48 (h!67 T!0) (t!100 (List!24 T!0))) (Nil!48))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!24 T!29))) (Set T!29) (ite (is-Nil!48 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!67 thiss!4)) (content!0 (t!100 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!24 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!48 thiss!10) (or (= (h!67 thiss!10) v!0) (contains!0 (t!100 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!24 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!87 (fun1!88 (f!253 (=> A1!50 R!72)) (pre!139 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!25 (~>!26 (f!256 (fun1!87 A!30 B!20)) (ens!13 (fun1!87 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!25 A!36 B!28))) (fun1!87 A!36 Bool) (fun1!88 (pre!139 (f!256 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!25 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!25 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!253 (fun1!88 (pre!139 (ens!13 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!253 (fun1!88 (pre!139 (f!256 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!253 (ens!13 thiss!2)) (@ (f!253 (f!256 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (and (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!24 A!31)) x!60) (@ (f!253 (pre!0 (as f!27 (~>!25 A!31 B!21)))) x!60))) (is-Cons!48 (as l!19 (List!24 A!31)))) (let ((x!61 (h!67 (as l!19 (List!24 A!31))))) (let ((xs!22 (t!100 (as l!19 (List!24 A!31))))) (forall ((x!60 A!31)) (=> (contains!0 xs!22 x!60) (@ (f!253 (pre!0 (as f!27 (~>!25 A!31 B!21)))) x!60)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-29.tip

(declare-datatypes () ((A!136 (Cons!49 (head!96 Int) (tail!101 A!136)) (Nil!49 (i!103 Int)))))

(declare-const thiss!8 A!136)

(define-fun inv!5 ((thiss!6 A!136)) Bool (>= (i!103 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!136)) Int (assume (or (is-Cons!49 thiss!5) (is-Nil!49 thiss!5)) (let ((i!14 (ite (is-Cons!49 thiss!5) (+ 1 (size!1 (tail!101 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!136)) Bool (ite (is-Nil!49 thiss!8) (inv!5 (assume (is-Nil!49 thiss!8) thiss!8)) (ite (is-Cons!49 thiss!8) (= (head!96 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!136 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (is-Cons!49 thiss!8) (not (is-Nil!49 thiss!8))) (let ((h!46 (head!96 thiss!8))) (let ((t!53 (tail!101 thiss!8))) (or (is-Cons!49 thiss!8) (is-Nil!49 thiss!8)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-3.tip

(declare-datatypes (A1!50 R!72) ((fun1!9 (fun1!11 (f!149 (=> A1!50 R!72)) (pre!90 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!1 (~>!2 (f!152 (fun1!9 A!30 B!20)) (ens!1 (fun1!9 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!1 A!35 B!27))))

(declare-const (par (B!27) (x!56 B!27)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!1 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!149 (fun1!11 (pre!90 (ens!1 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!149 (fun1!11 (pre!90 (f!152 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!149 (ens!1 thiss!2)) (@ (f!149 (f!152 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (@ (f!149 (fun1!11 (pre!90 (fun1!11 (pre!90 (ens!1 (as thiss!2 (~>!1 A!35 B!27)))) (lambda ((x!185 B!27)) true))) (lambda ((x!186 B!27)) true))) (as x!56 B!27)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-30.tip

(declare-datatypes () ((A!138 (A!139 (x!399 (_ BitVec 32))))))

(declare-datatypes (A!133) ((array!44 (array!45 (arr!23 (Array (_ BitVec 32) A!133)) (size!47 (_ BitVec 32))))))

(declare-datatypes () ((B!92 (B!93 (a!89 (array!44 A!138))))))

(datatype-invariant (par (A!132) array!41 (array!44 A!132) (bvsge (size!47 array!41) #b00000000000000000000000000000000)))

(assert (not (let ((b!118 (B!93 (array!45 (store (store (store ((as const (Array (_ BitVec 32) A!138)) (A!139 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!139 #b00000000000000000000000000000001)) #b00000000000000000000000000000001 (A!139 #b00000000000000000000000000000010)) #b00000000000000000000000000000010 (A!139 #b00000000000000000000000000000011)) #b00000000000000000000000000000011)))) (bvsgt (size!47 (a!89 b!118)) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-31.tip

(declare-datatypes () ((A!144 (Cons!52 (head!101 Int) (tail!106 A!144)) (Nil!52 (i!105 Int)))))

(declare-const thiss!5 A!144)

(define-fun inv!5 ((thiss!6 A!144)) Bool (>= (i!105 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!144)) Int (assume (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)) (let ((i!14 (ite (is-Cons!52 thiss!5) (+ 1 (size!1 (tail!106 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!144)) Bool (ite (is-Nil!52 thiss!8) (inv!5 (assume (is-Nil!52 thiss!8) thiss!8)) (ite (is-Cons!52 thiss!8) (= (head!101 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!144 (inv!4 (assume true thiss!3)))

(assert (not (=> (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)) (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-32.tip

(declare-datatypes () ((A!146 (A!147 (x!411 (_ BitVec 32))))))

(declare-datatypes (A!133) ((array!50 (array!51 (arr!26 (Array (_ BitVec 32) A!133)) (size!50 (_ BitVec 32))))))

(declare-datatypes () ((B!96 (B!97 (a!91 (array!50 A!146))))))

(define-fun foo!0 ((b!15 B!96)) (_ BitVec 32) (x!411 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!50 (a!91 b!15)))) (select (arr!26 (a!91 b!15)) #b00000000000000000000000000000000))))

(datatype-invariant (par (A!132) array!41 (array!50 A!132) (bvsge (size!50 array!41) #b00000000000000000000000000000000)))

(assert (not (let ((b!118 (B!97 (array!51 (store (store (store ((as const (Array (_ BitVec 32) A!146)) (A!147 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!147 #b00000000000000000000000000000001)) #b00000000000000000000000000000001 (A!147 #b00000000000000000000000000000010)) #b00000000000000000000000000000010 (A!147 #b00000000000000000000000000000011)) #b00000000000000000000000000000011)))) (let ((x$1!69 (foo!0 b!118))) (= x$1!69 #b00000000000000000000000000000001)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-33.tip

(declare-datatypes (T!0) ((List!27 (Cons!55 (h!70 T!0) (t!103 (List!27 T!0))) (Nil!55))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!27 T!29))) (Set T!29) (ite (is-Nil!55 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!70 thiss!4)) (content!0 (t!103 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!27 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!55 thiss!10) (or (= (h!70 thiss!10) v!0) (contains!0 (t!103 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!27 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!100 (fun1!101 (f!274 (=> A1!50 R!72)) (pre!156 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!29 (~>!30 (f!277 (fun1!100 A!30 B!20)) (ens!15 (fun1!100 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!29 A!36 B!28))) (fun1!100 A!36 Bool) (fun1!101 (pre!156 (f!277 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!29 A!31 B!21))))

(define-fun (par (A!37 B!29) (apply!2 ((thiss!9 (~>!29 A!37 B!29)) (x!58 A!37)) B!29 (assume (@ (f!274 (fun1!101 (pre!156 (f!277 thiss!9)) (lambda ((x!163 A!37)) true))) x!58) (let ((res!31 (@ (f!274 (f!277 thiss!9)) x!58))) (assume (@ (f!274 (ens!15 thiss!9)) res!31) res!31))))))

(define-fun-rec (par (A!31 B!21) (map!4 ((l!19 (List!27 A!31)) (f!27 (~>!29 A!31 B!21))) (List!27 B!21) (assume (forall ((x!60 A!31)) (=> (contains!0 l!19 x!60) (@ (f!274 (pre!0 f!27)) x!60))) (let ((res!32 (ite (is-Cons!55 l!19) (Cons!55 (apply!2 f!27 (h!70 l!19)) (map!4 (t!103 l!19) f!27)) (as Nil!55 (List!27 B!21))))) (assume (forall ((x!59 B!21)) (=> (contains!0 res!32 x!59) (@ (f!274 (ens!15 f!27)) x!59))) res!32))))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!29 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!274 (fun1!101 (pre!156 (ens!15 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!274 (fun1!101 (pre!156 (f!277 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!274 (ens!15 thiss!2)) (@ (f!274 (f!277 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!27 A!31)) x!60) (@ (f!274 (pre!0 (as f!27 (~>!29 A!31 B!21)))) x!60))) (let ((res!104 (ite (is-Cons!55 (as l!19 (List!27 A!31))) (Cons!55 (apply!2 (as f!27 (~>!29 A!31 B!21)) (h!70 (as l!19 (List!27 A!31)))) (map!4 (t!103 (as l!19 (List!27 A!31))) (as f!27 (~>!29 A!31 B!21)))) (as Nil!55 (List!27 B!21))))) (forall ((x!59 B!21)) (=> (contains!0 res!104 x!59) (@ (f!274 (ens!15 (as f!27 (~>!29 A!31 B!21)))) x!59))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-34.tip

(declare-datatypes () ((A!160 (A!161 (x!420 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!56 (array!57 (arr!29 (Array (_ BitVec 32) A!149)) (size!53 (_ BitVec 32))))))

(declare-datatypes () ((B!102 (B!103 (content!13 (array!56 A!160))))))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!56 A!148) (bvsge (size!53 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!102 (bvsgt (size!53 (content!13 thiss!45)) #b00000000000000000000000000000000))

(assert (not (let ((res!180 (B!103 (array!57 (store ((as const (Array (_ BitVec 32) A!160)) (A!161 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!161 y!7)) #b00000000000000000000000000000001)))) (= (x!420 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!53 (content!13 res!180)))) (select (arr!29 (content!13 res!180)) #b00000000000000000000000000000000))) y!7))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-35.tip

(declare-datatypes (T!0) ((List!30 (Cons!58 (h!72 T!0) (t!105 (List!30 T!0))) (Nil!58))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!30 T!29))) (Set T!29) (ite (is-Nil!58 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!72 thiss!4)) (content!0 (t!105 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!30 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!58 thiss!10) (or (= (h!72 thiss!10) v!0) (contains!0 (t!105 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!30 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!111 (fun1!112 (f!295 (=> A1!50 R!72)) (pre!172 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!33 (~>!34 (f!300 (fun1!111 A!30 B!20)) (ens!17 (fun1!111 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!33 A!36 B!28))) (fun1!111 A!36 Bool) (fun1!112 (pre!172 (f!300 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!33 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!33 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!295 (fun1!112 (pre!172 (ens!17 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!295 (fun1!112 (pre!172 (f!300 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!295 (ens!17 thiss!2)) (@ (f!295 (f!300 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!30 A!31)) x!60) (@ (f!295 (pre!0 (as f!27 (~>!33 A!31 B!21)))) x!60))) (or (is-Cons!58 (as l!19 (List!30 A!31))) (is-Nil!58 (as l!19 (List!30 A!31))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-36.tip

(declare-const index!2 (_ BitVec 32))

(declare-datatypes (A!165) ((array!60 (array!61 (arr!31 (Array (_ BitVec 32) A!165)) (size!55 (_ BitVec 32))))))

(declare-datatypes () ((HashTable!1 (HashTable!2 (table!1 (array!60 Int))))))

(declare-const thiss!44 HashTable!1)

(datatype-invariant (par (A!164) array!59 (array!60 A!164) (bvsge (size!55 array!59) #b00000000000000000000000000000000)))

(datatype-invariant thiss!43 HashTable!1 (bvsgt (size!55 (table!1 thiss!43)) #b00000000000000000000000000000000))

(assert (not (=> (and (bvsge index!2 #b00000000000000000000000000000000) (bvslt index!2 (size!55 (table!1 thiss!44)))) (and (bvsge index!2 #b00000000000000000000000000000000) (bvslt index!2 (size!55 (table!1 thiss!44)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-37.tip

(declare-datatypes (A!133) ((array!68 (array!69 (arr!35 (Array (_ BitVec 32) A!133)) (size!59 (_ BitVec 32))))))

(declare-datatypes () ((A!179 (A!180 (x!446 (_ BitVec 32))))))

(declare-datatypes () ((B!113 (B!114 (a!107 (array!68 A!179))))))

(declare-const b!15 B!113)

(datatype-invariant (par (A!132) array!41 (array!68 A!132) (bvsge (size!59 array!41) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!59 (a!107 b!15)) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!59 (a!107 b!15)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-38.tip

(declare-datatypes (A1!50 R!72) ((fun1!123 (fun1!124 (f!309 (=> A1!50 R!72)) (pre!178 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!37 (~>!38 (f!312 (fun1!123 A!30 B!20)) (ens!19 (fun1!123 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!37 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!37 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!309 (fun1!124 (pre!178 (ens!19 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!309 (fun1!124 (pre!178 (f!312 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!309 (ens!19 thiss!2)) (@ (f!309 (f!312 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!309 (fun1!124 (pre!178 (f!312 (as thiss!9 (~>!37 A!37 B!29)))) (lambda ((x!445 A!37)) true))) (as x!58 A!37)) (let ((res!103 (@ (f!309 (f!312 (as thiss!9 (~>!37 A!37 B!29)))) (as x!58 A!37)))) (@ (f!309 (ens!19 (as thiss!9 (~>!37 A!37 B!29)))) res!103))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-39.tip

(declare-datatypes (T!0) ((List!33 (Cons!61 (h!75 T!0) (t!108 (List!33 T!0))) (Nil!61))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!33 T!29))) (Set T!29) (ite (is-Nil!61 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!75 thiss!4)) (content!0 (t!108 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!33 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!61 thiss!10) (or (= (h!75 thiss!10) v!0) (contains!0 (t!108 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!33 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!157 (fun1!158 (f!344 (=> A1!50 R!72)) (pre!195 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!49 (~>!50 (f!347 (fun1!157 A!30 B!20)) (ens!25 (fun1!157 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!49 A!36 B!28))) (fun1!157 A!36 Bool) (fun1!158 (pre!195 (f!347 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!49 A!31 B!21))))

(define-fun (par (A!37 B!29) (apply!2 ((thiss!9 (~>!49 A!37 B!29)) (x!58 A!37)) B!29 (assume (@ (f!344 (fun1!158 (pre!195 (f!347 thiss!9)) (lambda ((x!163 A!37)) true))) x!58) (let ((res!31 (@ (f!344 (f!347 thiss!9)) x!58))) (assume (@ (f!344 (ens!25 thiss!9)) res!31) res!31))))))

(define-fun-rec (par (A!31 B!21) (map!4 ((l!19 (List!33 A!31)) (f!27 (~>!49 A!31 B!21))) (List!33 B!21) (assume (forall ((x!60 A!31)) (=> (contains!0 l!19 x!60) (@ (f!344 (pre!0 f!27)) x!60))) (let ((res!32 (ite (is-Cons!61 l!19) (Cons!61 (apply!2 f!27 (h!75 l!19)) (map!4 (t!108 l!19) f!27)) (as Nil!61 (List!33 B!21))))) (assume (forall ((x!59 B!21)) (=> (contains!0 res!32 x!59) (@ (f!344 (ens!25 f!27)) x!59))) res!32))))))

(declare-const (par (B!21) (x!59 B!21)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!49 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!344 (fun1!158 (pre!195 (ens!25 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!344 (fun1!158 (pre!195 (f!347 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!344 (ens!25 thiss!2)) (@ (f!344 (f!347 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!33 A!31)) x!60) (@ (f!344 (pre!0 (as f!27 (~>!49 A!31 B!21)))) x!60))) (let ((res!32 (ite (is-Cons!61 (as l!19 (List!33 A!31))) (Cons!61 (apply!2 (as f!27 (~>!49 A!31 B!21)) (h!75 (as l!19 (List!33 A!31)))) (map!4 (t!108 (as l!19 (List!33 A!31))) (as f!27 (~>!49 A!31 B!21)))) (as Nil!61 (List!33 B!21))))) (=> (contains!0 res!32 (as x!59 B!21)) (@ (f!344 (fun1!158 (pre!195 (ens!25 (as f!27 (~>!49 A!31 B!21)))) (lambda ((x!488 B!21)) true))) (as x!59 B!21))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-4.tip

(declare-datatypes (A!63) ((array!16 (array!19 (arr!9 (Array (_ BitVec 32) A!63)) (size!27 (_ BitVec 32))))))

(declare-datatypes () ((A1!88 (A1!89 (x!209 (_ BitVec 32))))))

(declare-datatypes () ((B!40 (B!41 (t!70 (array!16 A1!88))))))

(declare-const b!13 B!40)

(datatype-invariant (par (A!49) array!7 (array!16 A!49) (bvsge (size!27 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!27 (t!70 b!13)) #b00000000000000000000000000000000) (bvsgt (x!209 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!27 (t!70 b!13)))) (select (arr!9 (t!70 b!13)) #b00000000000000000000000000000000))) #b00000000000000000000000000000000)) (let ((a!41 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!27 (t!70 b!13)))) (select (arr!9 (t!70 b!13)) #b00000000000000000000000000000000)))) (bvsge (x!209 a!41) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-40.tip

(declare-datatypes (A1!50 R!72) ((fun1!135 (fun1!136 (f!329 (=> A1!50 R!72)) (pre!184 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!41 (~>!42 (f!332 (fun1!135 A!30 B!20)) (ens!21 (fun1!135 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!41 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!41 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!329 (fun1!136 (pre!184 (ens!21 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!329 (fun1!136 (pre!184 (f!332 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!329 (ens!21 thiss!2)) (@ (f!329 (f!332 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!329 (fun1!136 (pre!184 (f!332 (as thiss!9 (~>!41 A!37 B!29)))) (lambda ((x!467 A!37)) true))) (as x!58 A!37)) (@ (f!329 (fun1!136 (pre!184 (f!332 (as thiss!9 (~>!41 A!37 B!29)))) (lambda ((x!468 A!37)) true))) (as x!58 A!37))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-41.tip

(declare-datatypes (A1!50 R!72) ((fun1!141 (fun1!142 (f!333 (=> A1!50 R!72)) (pre!187 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!43 (~>!44 (f!336 (fun1!141 A!30 B!20)) (ens!22 (fun1!141 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!43 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!43 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!333 (fun1!142 (pre!187 (ens!22 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!333 (fun1!142 (pre!187 (f!336 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!333 (ens!22 thiss!2)) (@ (f!333 (f!336 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (@ (f!333 (fun1!142 (pre!187 (fun1!142 (pre!187 (f!336 (as thiss!9 (~>!43 A!37 B!29)))) (lambda ((x!469 A!37)) true))) (lambda ((x!470 A!37)) true))) (as x!58 A!37)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-42.tip

(declare-datatypes () ((A!191 (A!192 (x!471 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!78 (array!79 (arr!40 (Array (_ BitVec 32) A!149)) (size!64 (_ BitVec 32))))))

(declare-datatypes () ((B!127 (B!128 (content!15 (array!78 A!191))))))

(define-fun inv!7 ((thiss!45 B!127)) Bool (bvsgt (size!64 (content!15 thiss!45)) #b00000000000000000000000000000000))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!78 A!148) (bvsge (size!64 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!127 (bvsgt (size!64 (content!15 thiss!45)) #b00000000000000000000000000000000))

(assert (not (inv!7 (B!128 (array!79 (store ((as const (Array (_ BitVec 32) A!191)) (A!192 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!192 y!7)) #b00000000000000000000000000000001)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-43.tip

(declare-datatypes () ((A!205 (A!206 (x!504 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!84 (array!85 (arr!43 (Array (_ BitVec 32) A!149)) (size!69 (_ BitVec 32))))))

(declare-datatypes () ((B!137 (B!138 (content!18 (array!84 A!205))))))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!84 A!148) (bvsge (size!69 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!137 (bvsgt (size!69 (content!18 thiss!45)) #b00000000000000000000000000000000))

(assert (not (let ((res!34 (B!138 (array!85 (store ((as const (Array (_ BitVec 32) A!205)) (A!206 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!206 y!7)) #b00000000000000000000000000000001)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!69 (content!18 res!34)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-44.tip

(declare-datatypes (A1!50 R!72) ((fun1!167 (fun1!168 (f!351 (=> A1!50 R!72)) (pre!200 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!53 (~>!54 (f!354 (fun1!167 A!30 B!20)) (ens!27 (fun1!167 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!53 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!53 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!351 (fun1!168 (pre!200 (ens!27 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!351 (fun1!168 (pre!200 (f!354 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!351 (ens!27 thiss!2)) (@ (f!351 (f!354 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!351 (fun1!168 (pre!200 (f!354 (as thiss!9 (~>!53 A!37 B!29)))) (lambda ((x!520 A!37)) true))) (as x!58 A!37)) (let ((res!31 (@ (f!351 (f!354 (as thiss!9 (~>!53 A!37 B!29)))) (as x!58 A!37)))) (@ (f!351 (fun1!168 (pre!200 (ens!27 (as thiss!9 (~>!53 A!37 B!29)))) (lambda ((x!521 B!29)) true))) res!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-45.tip

(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!181 (fun1!182 (f!393 (=> A1!174 R!188)) (pre!228 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!182 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!129 Int)) true)))) (let ((res!259 (+ (@ (f!393 i!18) x!72) (@ (f!393 i!18) 2)))) (> res!259 0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-46.tip

(declare-datatypes (A!219) ((array!92 (array!93 (arr!47 (Array (_ BitVec 32) A!219)) (size!77 (_ BitVec 32))))))

(declare-const a!25 (array!92 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!92 A!218) (bvsge (size!77 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!77 a!25) #b00000000000000000000000000000010) (let ((res!258 (array!93 (store (arr!47 a!25) (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!77 a!25))) #b00000000000000000000000000000001) #b00000000000000000000000000000011) (size!77 a!25)))) (and (= (size!77 res!258) (size!77 a!25)) (= (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!77 res!258))) (select (arr!47 res!258) #b00000000000000000000000000000001)) #b00000000000000000000000000000011))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-47.tip

(declare-datatypes (A!225) ((array!102 (array!103 (arr!52 (Array (_ BitVec 32) A!225)) (size!82 (_ BitVec 32))))))

(datatype-invariant (par (A!224) array!97 (array!102 A!224) (bvsge (size!82 array!97) #b00000000000000000000000000000000)))

(assert (not (let ((a!126 (array!103 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000101) #b00000000000000000000000000000101))) (and (bvsgt (size!82 a!126) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!82 a!126))) (select (arr!52 a!126) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-48.tip

(declare-datatypes (A!219) ((array!98 (array!99 (arr!50 (Array (_ BitVec 32) A!219)) (size!80 (_ BitVec 32))))))

(declare-const a!25 (array!98 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!98 A!218) (bvsge (size!80 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!80 a!25) #b00000000000000000000000000000010) (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!80 a!25))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-49.tip

(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!184 (fun1!185 (f!407 (=> A1!174 R!188)) (pre!241 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!185 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!133 Int)) true)))) (@ (f!407 (fun1!185 (pre!241 i!18) (lambda ((x!621 Int)) true))) x!72)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-5.tip

(declare-const x!63 Int)

(declare-const y!6 Int)

(assert (not (=> (and (>= x!63 0) (>= y!6 0)) (let ((x$1!23 (+ x!63 y!6))) (>= x$1!23 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-50.tip

(declare-datatypes (A!219) ((array!106 (array!107 (arr!54 (Array (_ BitVec 32) A!219)) (size!84 (_ BitVec 32))))))

(declare-const a!25 (array!106 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!106 A!218) (bvsge (size!84 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!84 a!25) #b00000000000000000000000000000010) (let ((res!37 (array!107 (store (arr!54 a!25) (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!84 a!25))) #b00000000000000000000000000000001) #b00000000000000000000000000000011) (size!84 a!25)))) (=> (= (size!84 res!37) (size!84 a!25)) (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!84 res!37))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-51.tip

(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!186 (fun1!187 (f!409 (=> A1!174 R!188)) (pre!243 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!187 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!135 Int)) true)))) (@ (f!409 (fun1!187 (pre!243 i!18) (lambda ((x!627 Int)) true))) 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-52.tip

(declare-datatypes (A!225) ((array!110 (array!111 (arr!56 (Array (_ BitVec 32) A!225)) (size!90 (_ BitVec 32))))))

(declare-const a!23 (array!110 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!110 A!224) (bvsge (size!90 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!90 a!23) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!90 a!23))) (select (arr!56 a!23) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)) (let ((x$1!76 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!90 a!23))) (select (arr!56 a!23) #b00000000000000000000000000000010)))) (= x$1!76 #b00000000000000000000000000000101)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-53.tip

(declare-datatypes (A!225) ((array!114 (array!115 (arr!58 (Array (_ BitVec 32) A!225)) (size!94 (_ BitVec 32))))))

(declare-const a!23 (array!114 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!114 A!224) (bvsge (size!94 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!94 a!23) #b00000000000000000000000000000010) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!94 a!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-54.tip

(declare-datatypes (A!225) ((array!118 (array!119 (arr!60 (Array (_ BitVec 32) A!225)) (size!96 (_ BitVec 32))))))

(declare-const a!23 (array!118 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!118 A!224) (bvsge (size!96 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!96 a!23) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!96 a!23))) (select (arr!60 a!23) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!96 a!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-55.tip

(declare-datatypes (A!239) ((array!126 (array!127 (arr!64 (Array (_ BitVec 32) A!239)) (size!100 (_ BitVec 32))))))

(datatype-invariant (par (A!238) array!123 (array!126 A!238) (bvsge (size!100 array!123) #b00000000000000000000000000000000)))

(assert (not (let ((b!351 (array!127 (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001) #b00000000000000000000000000000001 #b00000000000000000000000000000010) #b00000000000000000000000000000010 #b00000000000000000000000000000011) #b00000000000000000000000000000011))) (let ((a!139 (array!127 (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001) #b00000000000000000000000000000001 #b00000000000000000000000000000010) #b00000000000000000000000000000010 #b00000000000000000000000000000011) #b00000000000000000000000000000011))) (let ((x$1!78 (size!100 a!139))) (bvsgt x$1!78 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-56.tip

(declare-datatypes (A!241) ((array!128 (array!129 (arr!65 (Array (_ BitVec 32) A!241)) (size!101 (_ BitVec 32))))))

(datatype-invariant (par (A!240) array!125 (array!128 A!240) (bvsge (size!101 array!125) #b00000000000000000000000000000000)))

(assert (not (let ((x!74 #b00000000000000000000000000001010)) (let ((a!138 (array!129 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!74) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (let ((x$1!79 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!101 a!138))) (select (arr!65 a!138) #b00000000000000000000000000000010)))) (bvsge x$1!79 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-57.tip

(declare-datatypes (A!241) ((array!136 (array!137 (arr!69 (Array (_ BitVec 32) A!241)) (size!105 (_ BitVec 32))))))

(datatype-invariant (par (A!240) array!125 (array!136 A!240) (bvsge (size!105 array!125) #b00000000000000000000000000000000)))

(assert (not (let ((x!74 #b00000000000000000000000000001010)) (let ((a!138 (array!137 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!74) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!105 a!138)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-58.tip

(declare-const x!73 (_ BitVec 32))

(declare-datatypes (A!247) ((array!144 (array!145 (arr!73 (Array (_ BitVec 32) A!247)) (size!111 (_ BitVec 32))))))

(datatype-invariant (par (A!246) array!133 (array!144 A!246) (bvsge (size!111 array!133) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge x!73 #b00000000000000000000000000000000) (let ((a!141 (array!145 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!73) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (let ((x$1!80 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!111 a!141))) (select (arr!73 a!141) #b00000000000000000000000000000010)))) (bvsge x$1!80 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-59.tip

(declare-const i!20 (_ BitVec 32))

(assert (not (=> (bvsgt i!20 #b00000000000000000000000000000000) (bvsgt i!20 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-6.tip

(declare-const x!62 Int)

(declare-datatypes () ((Acc!3 (Acc!4 (checking!1 Int) (savings!1 Int)))))

(define-fun notRed!0 ((a!17 Acc!3)) Bool (and (>= (checking!1 a!17) 0) (>= (savings!1 a!17) 0)))

(declare-const a!16 Acc!3)

(define-fun sameTotal!0 ((a1!0 Acc!3) (a2!0 Acc!3)) Bool (= (+ (checking!1 a1!0) (savings!1 a1!0)) (+ (checking!1 a2!0) (savings!1 a2!0))))

(assert (not (=> (and (and (> x!62 0) (notRed!0 a!16)) (>= (checking!1 a!16) x!62)) (let ((r!65 (Acc!4 (- (checking!1 a!16) x!62) (+ (savings!1 a!16) x!62)))) (and (notRed!0 r!65) (sameTotal!0 a!16 r!65))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-60.tip

(declare-datatypes () ((List!38 (Cons!79 (head!126 (_ BitVec 32)) (tail!132 List!38)) (Nil!79))))

(declare-datatypes () ((AbsQueue!1 (Queue!1 (front!8 List!38) (rear!7 List!38)))))

(define-fun-rec size!2 ((list!0 List!38)) Int (let ((x$1!6 (ite (is-Nil!79 list!0) 0 (+ 1 (size!2 (tail!132 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!38)) (Set (_ BitVec 32)) (ite (is-Nil!79 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!126 l!21)) (content!4 (tail!132 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!38) (l2!10 List!38)) List!38 (let ((res!35 (ite (is-Nil!79 l1!12) l2!10 (Cons!79 (head!126 l1!12) (concat!0 (tail!132 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!38)) List!38 (let ((x$2!4 (ite (is-Nil!79 l!22) Nil!79 (concat!0 (reverse!1 (tail!132 l!22)) (Cons!79 (head!126 l!22) Nil!79))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!1)) List!38 (concat!0 (front!8 queue!0) (reverse!1 (rear!7 queue!0))))

(declare-const queue!6 AbsQueue!1)

(declare-const list!1 List!38)

(define-fun isEmpty!2 ((queue!2 AbsQueue!1)) Bool (ite (and (is-Queue!1 queue!2) (is-Nil!79 (front!8 queue!2)) (is-Nil!79 (rear!7 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!1)) Bool (>= (size!2 (front!8 queue!1)) (size!2 (rear!7 queue!1))))

(assert (not (=> (and (= (asList!0 queue!6) list!1) (is-Cons!79 list!1)) (let ((x!71 (head!126 list!1))) (=> (and (is-Queue!1 queue!6) (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6)) (and (isAmortized!0 queue!6) (not (isEmpty!2 queue!6))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-61.tip

(declare-datatypes (A!259) ((array!150 (array!151 (arr!76 (Array (_ BitVec 32) A!259)) (size!115 (_ BitVec 32))))))

(declare-const a!30 (array!150 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!150 A!258) (bvsge (size!115 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!115 a!30) #b00000000000000000000000000000000) (let ((a2!8 (array!151 (store (arr!76 a!30) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!115 a!30))) #b00000000000000000000000000000000) #b00000000000000000000000000000010) (size!115 a!30)))) (let ((res!293 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!115 a2!8))) (select (arr!76 a2!8) #b00000000000000000000000000000000)))) (= res!293 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-62.tip

(declare-const a!32 Int)

(assert (not (=> (> a!32 0) (> 1 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-63.tip

(declare-datatypes () ((List!40 (Cons!81 (head!128 (_ BitVec 32)) (tail!134 List!40)) (Nil!81))))

(declare-datatypes () ((AbsQueue!3 (Queue!3 (front!10 List!40) (rear!9 List!40)))))

(declare-const queue!6 AbsQueue!3)

(define-fun isEmpty!2 ((queue!2 AbsQueue!3)) Bool (ite (and (is-Queue!3 queue!2) (is-Nil!81 (front!10 queue!2)) (is-Nil!81 (rear!9 queue!2))) true false))

(define-fun-rec size!2 ((list!0 List!40)) Int (let ((x$1!6 (ite (is-Nil!81 list!0) 0 (+ 1 (size!2 (tail!134 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!3)) Bool (>= (size!2 (front!10 queue!1)) (size!2 (rear!9 queue!1))))

(define-fun-rec content!4 ((l!21 List!40)) (Set (_ BitVec 32)) (ite (is-Nil!81 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!128 l!21)) (content!4 (tail!134 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!40) (l2!10 List!40)) List!40 (let ((res!35 (ite (is-Nil!81 l1!12) l2!10 (Cons!81 (head!128 l1!12) (concat!0 (tail!134 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!40)) List!40 (let ((x$2!4 (ite (is-Nil!81 l!22) Nil!81 (concat!0 (reverse!1 (tail!134 l!22)) (Cons!81 (head!128 l!22) Nil!81))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!3)) List!40 (concat!0 (front!10 queue!0) (reverse!1 (rear!9 queue!0))))

(declare-const list!1 List!40)

(define-fun front!5 ((queue!5 AbsQueue!3)) (_ BitVec 32) (head!128 (front!10 queue!5)))

(assert (not (=> (and (is-Queue!3 queue!6) (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6)) (ite (= (asList!0 queue!6) list!1) (= (front!5 queue!6) (head!128 list!1)) true))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-64.tip

(declare-const x!73 (_ BitVec 32))

(declare-datatypes (A!247) ((array!156 (array!157 (arr!79 (Array (_ BitVec 32) A!247)) (size!118 (_ BitVec 32))))))

(datatype-invariant (par (A!246) array!133 (array!156 A!246) (bvsge (size!118 array!133) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge x!73 #b00000000000000000000000000000000) (let ((a!141 (array!157 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!73) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!118 a!141)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-65.tip

(declare-const i!20 (_ BitVec 32))

(declare-datatypes (A!251) ((array!160 (array!161 (arr!81 (Array (_ BitVec 32) A!251)) (size!120 (_ BitVec 32))))))

(define-fun foo!3 ((i!19 (_ BitVec 32))) (array!160 (_ BitVec 32)) (assume (bvsgt i!19 #b00000000000000000000000000000000) (let ((res!38 (array!161 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) i!19))) (assume (= (size!120 res!38) i!19) res!38))))

(datatype-invariant (par (A!250) array!141 (array!160 A!250) (bvsge (size!120 array!141) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt i!20 #b00000000000000000000000000000000) (let ((b!352 (foo!3 i!20))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!120 b!352)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-66.tip

(declare-const a!32 Int)

(define-fun bar!2 ((a!33 Int)) Int (assume (> a!33 0) (let ((x$4!2 (assume (> a!33 0) (+ a!33 2)))) (assume (> x$4!2 a!33) x$4!2))))

(assert (not (=> (> a!32 0) (let ((x$2!37 (assume (> a!32 0) (+ a!32 (bar!2 1))))) (> x$2!37 a!32)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-67.tip

(declare-datatypes (A!259) ((array!164 (array!165 (arr!83 (Array (_ BitVec 32) A!259)) (size!122 (_ BitVec 32))))))

(declare-const a!30 (array!164 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!164 A!258) (bvsge (size!122 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!122 a!30) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!122 a!30))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-68.tip

(declare-datatypes () ((List!42 (Cons!83 (head!130 (_ BitVec 32)) (tail!136 List!42)) (Nil!83))))

(declare-datatypes () ((AbsQueue!5 (Queue!5 (front!12 List!42) (rear!11 List!42)))))

(define-fun-rec size!2 ((list!0 List!42)) Int (let ((x$1!6 (ite (is-Nil!83 list!0) 0 (+ 1 (size!2 (tail!136 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!5)) Bool (>= (size!2 (front!12 queue!1)) (size!2 (rear!11 queue!1))))

(declare-const queue!5 AbsQueue!5)

(define-fun isEmpty!2 ((queue!2 AbsQueue!5)) Bool (ite (and (is-Queue!5 queue!2) (is-Nil!83 (front!12 queue!2)) (is-Nil!83 (rear!11 queue!2))) true false))

(assert (not (=> (and (isAmortized!0 queue!5) (not (isEmpty!2 queue!5))) (and (is-Queue!5 queue!5) (is-Cons!83 (front!12 queue!5))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-69.tip

(declare-const i!19 (_ BitVec 32))

(declare-datatypes (A!251) ((array!168 (array!169 (arr!85 (Array (_ BitVec 32) A!251)) (size!124 (_ BitVec 32))))))

(datatype-invariant (par (A!250) array!141 (array!168 A!250) (bvsge (size!124 array!141) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt i!19 #b00000000000000000000000000000000) (let ((res!286 (array!169 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) i!19))) (= (size!124 res!286) i!19)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-7.tip

(declare-datatypes (A!57) ((array!17 (array!18 (arr!10 (Array (_ BitVec 32) A!57)) (size!28 (_ BitVec 32))))))

(declare-datatypes () ((A1!86 (A1!87 (x!208 (_ BitVec 32))))))

(declare-datatypes () ((B!38 (B!39 (t!69 (array!17 A1!86))))))

(declare-const b!14 B!38)

(datatype-invariant (par (A!48) array!5 (array!17 A!48) (bvsge (size!28 array!5) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!28 (t!69 b!14)) #b00000000000000000000000000000010) (let ((a!40 (size!28 (t!69 b!14)))) (bvsgt a!40 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-70.tip

(declare-datatypes (A!259) ((array!170 (array!171 (arr!86 (Array (_ BitVec 32) A!259)) (size!125 (_ BitVec 32))))))

(declare-const a!30 (array!170 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!170 A!258) (bvsge (size!125 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!125 a!30) #b00000000000000000000000000000000) (let ((a2!8 (array!171 (store (arr!86 a!30) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!125 a!30))) #b00000000000000000000000000000000) #b00000000000000000000000000000010) (size!125 a!30)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!125 a2!8)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-71.tip

(declare-const a!32 Int)

(assert (not (=> (> a!32 0) (> a!32 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-72.tip

(declare-datatypes (A!259) ((array!176 (array!177 (arr!89 (Array (_ BitVec 32) A!259)) (size!128 (_ BitVec 32))))))

(declare-const a!31 (array!176 Int))

(datatype-invariant (par (A!258) array!149 (array!176 A!258) (bvsge (size!128 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!128 a!31) #b00000000000000000000000000000000) (let ((a2!9 (array!177 (store (arr!89 a!31) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!128 a!31))) #b00000000000000000000000000000000) 2) (size!128 a!31)))) (let ((res!294 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!128 a2!9))) (select (arr!89 a2!9) #b00000000000000000000000000000000)))) (= res!294 2))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-73.tip

(declare-datatypes (A!259) ((array!180 (array!181 (arr!91 (Array (_ BitVec 32) A!259)) (size!130 (_ BitVec 32))))))

(declare-const a!31 (array!180 Int))

(datatype-invariant (par (A!258) array!149 (array!180 A!258) (bvsge (size!130 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!130 a!31) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!130 a!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-74.tip

(declare-const a!33 Int)

(assert (not (=> (> a!33 0) (let ((x$4!12 (assume (> a!33 0) (+ a!33 2)))) (> x$4!12 a!33)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-75.tip

(declare-datatypes (A!259) ((array!186 (array!187 (arr!94 (Array (_ BitVec 32) A!259)) (size!133 (_ BitVec 32))))))

(declare-const a!31 (array!186 Int))

(datatype-invariant (par (A!258) array!149 (array!186 A!258) (bvsge (size!133 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!133 a!31) #b00000000000000000000000000000000) (let ((a2!9 (array!187 (store (arr!94 a!31) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!133 a!31))) #b00000000000000000000000000000000) 2) (size!133 a!31)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!133 a2!9)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-76.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!22 (fun2!23 (f!499 (=> A1!271 A2!189 R!294)) (pre!333 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!22 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!22 B!30 B!30 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!499 (fun2!23 (pre!333 (as f1!0 (fun2!22 A!41 A!41 A!41))) (lambda ((x!678 A!41) (x!679 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!499 (fun2!23 (pre!333 (as f2!1 (fun2!22 B!30 B!30 B!30))) (lambda ((x!680 B!30) (x!681 B!30)) true))) x!653 x!654))) (forall ((x!649 A!41)(x!650 A!41)) (@ (f!499 (fun2!23 (pre!333 (as f1!0 (fun2!22 A!41 A!41 A!41))) (lambda ((x!682 A!41) (x!683 A!41)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-77.tip

(declare-const a!33 Int)

(assert (not (=> (> a!33 0) (> a!33 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-78.tip

(declare-datatypes () ((List!44 (Cons!85 (head!132 (_ BitVec 32)) (tail!138 List!44)) (Nil!85))))

(declare-datatypes () ((AbsQueue!7 (Queue!7 (front!14 List!44) (rear!13 List!44)))))

(define-fun-rec size!2 ((list!0 List!44)) Int (let ((x$1!6 (ite (is-Nil!85 list!0) 0 (+ 1 (size!2 (tail!138 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!7)) Bool (>= (size!2 (front!14 queue!1)) (size!2 (rear!13 queue!1))))

(declare-const queue!4 AbsQueue!7)

(define-fun isEmpty!2 ((queue!2 AbsQueue!7)) Bool (ite (and (is-Queue!7 queue!2) (is-Nil!85 (front!14 queue!2)) (is-Nil!85 (rear!13 queue!2))) true false))

(define-fun-rec content!4 ((l!21 List!44)) (Set (_ BitVec 32)) (ite (is-Nil!85 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!132 l!21)) (content!4 (tail!138 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!44) (l2!10 List!44)) List!44 (let ((res!35 (ite (is-Nil!85 l1!12) l2!10 (Cons!85 (head!132 l1!12) (concat!0 (tail!138 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!44)) List!44 (let ((x$2!4 (ite (is-Nil!85 l!22) Nil!85 (concat!0 (reverse!1 (tail!138 l!22)) (Cons!85 (head!132 l!22) Nil!85))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun amortizedQueue!0 ((front!3 List!44) (rear!3 List!44)) AbsQueue!7 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!7 front!3 rear!3) (Queue!7 (concat!0 front!3 (reverse!1 rear!3)) Nil!85)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(assert (not (=> (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!4 (amortizedQueue!0 (tail!138 (front!14 queue!4)) (rear!13 queue!4)))) (isAmortized!0 x$5!4)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-79.tip

(declare-const x!81 Real)

(assert (not (= (assume (not (= (/ 2 1) (/ 0 1))) (/ x!81 (/ 2 1))) (* x!81 (/ 1 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-8.tip

(declare-datatypes (A!63) ((array!28 (array!29 (arr!15 (Array (_ BitVec 32) A!63)) (size!35 (_ BitVec 32))))))

(declare-datatypes () ((A1!94 (A1!95 (x!294 (_ BitVec 32))))))

(declare-datatypes () ((B!55 (B!56 (t!85 (array!28 A1!94))))))

(declare-const b!13 B!55)

(datatype-invariant (par (A!49) array!7 (array!28 A!49) (bvsge (size!35 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!35 (t!85 b!13)) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!35 (t!85 b!13)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-80.tip

(declare-datatypes () ((List!46 (Cons!87 (head!134 (_ BitVec 32)) (tail!140 List!46)) (Nil!87))))

(declare-const l!22 List!46)

(define-fun-rec size!2 ((list!0 List!46)) Int (let ((x$1!6 (ite (is-Nil!87 list!0) 0 (+ 1 (size!2 (tail!140 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!46)) (Set (_ BitVec 32)) (ite (is-Nil!87 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!134 l!21)) (content!4 (tail!140 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!46) (l2!10 List!46)) List!46 (let ((res!35 (ite (is-Nil!87 l1!12) l2!10 (Cons!87 (head!134 l1!12) (concat!0 (tail!140 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!46)) List!46 (let ((x$2!4 (ite (is-Nil!87 l!22) Nil!87 (concat!0 (reverse!1 (tail!140 l!22)) (Cons!87 (head!134 l!22) Nil!87))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(assert (not (let ((x$2!36 (ite (is-Nil!87 l!22) Nil!87 (concat!0 (reverse!1 (tail!140 l!22)) (Cons!87 (head!134 l!22) Nil!87))))) (= (content!4 x$2!36) (content!4 l!22)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-81.tip

(declare-datatypes () ((List!47 (Cons!89 (head!136 (_ BitVec 32)) (tail!142 List!47)) (Nil!89))))

(declare-datatypes () ((AbsQueue!9 (Queue!9 (front!16 List!47) (rear!15 List!47)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!9)) Bool (ite (and (is-Queue!9 queue!2) (is-Nil!89 (front!16 queue!2)) (is-Nil!89 (rear!15 queue!2))) true false))

(declare-const front!6 List!47)

(declare-const rear!6 List!47)

(define-fun-rec size!2 ((list!0 List!47)) Int (let ((x$1!6 (ite (is-Nil!89 list!0) 0 (+ 1 (size!2 (tail!142 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!9)) Bool (>= (size!2 (front!16 queue!1)) (size!2 (rear!15 queue!1))))

(define-fun-rec content!4 ((l!21 List!47)) (Set (_ BitVec 32)) (ite (is-Nil!89 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!136 l!21)) (content!4 (tail!142 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!47) (l2!10 List!47)) List!47 (let ((res!35 (ite (is-Nil!89 l1!12) l2!10 (Cons!89 (head!136 l1!12) (concat!0 (tail!142 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!47)) List!47 (let ((x$2!4 (ite (is-Nil!89 l!22) Nil!89 (concat!0 (reverse!1 (tail!142 l!22)) (Cons!89 (head!136 l!22) Nil!89))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!9)) List!47 (concat!0 (front!16 queue!0) (reverse!1 (rear!15 queue!0))))

(declare-const list!2 List!47)

(assert (not (=> (and (not (isEmpty!2 (Queue!9 front!6 rear!6))) (isAmortized!0 (Queue!9 front!6 rear!6)) (= (asList!0 (Queue!9 front!6 rear!6)) list!2)) (is-Cons!89 list!2))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-82.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!29 (fun2!30 (f!513 (=> A1!271 A2!189 R!294)) (pre!347 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!29 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!29 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!29 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!513 f!31) (@ (f!513 f!31) x!76 y!8) z!9) (@ (f!513 f!31) x!76 (@ (f!513 f!31) y!8 z!9)))))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!513 (fun2!30 (pre!347 (as f1!0 (fun2!29 A!41 A!41 A!41))) (lambda ((x!714 A!41) (x!715 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!513 (fun2!30 (pre!347 (as f2!1 (fun2!29 B!30 B!30 B!30))) (lambda ((x!716 B!30) (x!717 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!29 A!41 A!41 A!41)))) (forall ((x!649 B!30)(x!650 B!30)) (@ (f!513 (fun2!30 (pre!347 (as f2!1 (fun2!29 B!30 B!30 B!30))) (lambda ((x!718 B!30) (x!719 B!30)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-83.tip

(assert (not (not (= (/ 2 1) (/ 0 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-84.tip

(declare-datatypes () ((List!50 (Cons!92 (head!139 (_ BitVec 32)) (tail!145 List!50)) (Nil!92))))

(declare-datatypes () ((AbsQueue!11 (Queue!11 (front!18 List!50) (rear!17 List!50)))))

(define-fun-rec size!2 ((list!0 List!50)) Int (let ((x$1!6 (ite (is-Nil!92 list!0) 0 (+ 1 (size!2 (tail!145 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!11)) Bool (>= (size!2 (front!18 queue!1)) (size!2 (rear!17 queue!1))))

(declare-const queue!4 AbsQueue!11)

(define-fun isEmpty!2 ((queue!2 AbsQueue!11)) Bool (ite (and (is-Queue!11 queue!2) (is-Nil!92 (front!18 queue!2)) (is-Nil!92 (rear!17 queue!2))) true false))

(assert (not (=> (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (and (is-Queue!11 queue!4) (is-Cons!92 (front!18 queue!4))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-85.tip

(declare-datatypes () ((List!52 (Cons!94 (head!141 (_ BitVec 32)) (tail!147 List!52)) (Nil!94))))

(declare-datatypes () ((AbsQueue!13 (Queue!13 (front!20 List!52) (rear!19 List!52)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!13)) Bool (ite (and (is-Queue!13 queue!2) (is-Nil!94 (front!20 queue!2)) (is-Nil!94 (rear!19 queue!2))) true false))

(declare-const queue!6 AbsQueue!13)

(define-fun-rec size!2 ((list!0 List!52)) Int (let ((x$1!6 (ite (is-Nil!94 list!0) 0 (+ 1 (size!2 (tail!147 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!13)) Bool (>= (size!2 (front!20 queue!1)) (size!2 (rear!19 queue!1))))

(define-fun-rec content!4 ((l!21 List!52)) (Set (_ BitVec 32)) (ite (is-Nil!94 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!141 l!21)) (content!4 (tail!147 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!52) (l2!10 List!52)) List!52 (let ((res!35 (ite (is-Nil!94 l1!12) l2!10 (Cons!94 (head!141 l1!12) (concat!0 (tail!147 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!52)) List!52 (let ((x$2!4 (ite (is-Nil!94 l!22) Nil!94 (concat!0 (reverse!1 (tail!147 l!22)) (Cons!94 (head!141 l!22) Nil!94))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!13)) List!52 (concat!0 (front!20 queue!0) (reverse!1 (rear!19 queue!0))))

(declare-const list!1 List!52)

(assert (not (=> (and (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6) (= (asList!0 queue!6) list!1)) (is-Cons!94 list!1))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-86.tip

(declare-const x!80 Real)

(declare-const y!12 Real)

(assert (not (let ((res!311 (ite (>= x!80 y!12) x!80 y!12))) (and (and (or (= res!311 x!80) (= res!311 y!12)) (>= res!311 x!80)) (>= res!311 y!12)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-87.tip

(declare-const x!79 Real)

(declare-const y!11 Real)

(assert (not (=> (and (>= x!79 (/ 0 1)) (>= y!11 (/ 0 1))) (let ((x$1!81 (+ x!79 y!11))) (>= x$1!81 (/ 0 1))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-88.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!35 (fun2!36 (f!517 (=> A1!271 A2!189 R!294)) (pre!350 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!35 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!35 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!35 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!517 f!31) (@ (f!517 f!31) x!76 y!8) z!9) (@ (f!517 f!31) x!76 (@ (f!517 f!31) y!8 z!9)))))))

(declare-datatypes (A0!0 A1!306) ((tuple2!0 (tuple2!1 (_1!0 A0!0) (_2!0 A1!306)))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!517 (fun2!36 (pre!350 (as f1!0 (fun2!35 A!41 A!41 A!41))) (lambda ((x!753 A!41) (x!754 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!517 (fun2!36 (pre!350 (as f2!1 (fun2!35 B!30 B!30 B!30))) (lambda ((x!755 B!30) (x!756 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!35 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!35 B!30 B!30 B!30)))) (let ((fp!0 (fun2!36 (lambda ((p1!0 (tuple2!0 A!41 B!30)) (p2!0 (tuple2!0 A!41 B!30))) (tuple2!1 (@ (f!517 (as f1!0 (fun2!35 A!41 A!41 A!41))) (_1!0 p1!0) (_1!0 p2!0)) (@ (f!517 (as f2!1 (fun2!35 B!30 B!30 B!30))) (_2!0 p1!0) (_2!0 p2!0)))) (lambda ((p1!7 (tuple2!0 A!41 B!30)) (p2!9 (tuple2!0 A!41 B!30))) (and (@ (f!517 (fun2!36 (pre!350 (as f1!0 (fun2!35 A!41 A!41 A!41))) (lambda ((x!757 A!41) (x!758 A!41)) true))) (_1!0 p1!7) (_1!0 p2!9)) (@ (f!517 (fun2!36 (pre!350 (as f2!1 (fun2!35 B!30 B!30 B!30))) (lambda ((x!759 B!30) (x!760 B!30)) true))) (_2!0 p1!7) (_2!0 p2!9))))))) (forall ((x!649 (tuple2!0 A!41 B!30))(x!650 (tuple2!0 A!41 B!30))) (@ (f!517 (fun2!36 (pre!350 fp!0) (lambda ((x!761 (tuple2!0 A!41 B!30)) (x!762 (tuple2!0 A!41 B!30))) true))) x!649 x!650)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-89.tip

(declare-const x!82 Real)

(assert (not (=> (> x!82 (/ 0 1)) (let ((res!312 (* (/ 2 1) x!82))) (> res!312 x!82)))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-9.tip

(declare-datatypes (A1!50 R!72) ((fun1!22 (fun1!23 (f!190 (=> A1!50 R!72)) (pre!96 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!5 (~>!6 (f!193 (fun1!22 A!30 B!20)) (ens!3 (fun1!22 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!5 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!5 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!190 (fun1!23 (pre!96 (ens!3 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!190 (fun1!23 (pre!96 (f!193 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!190 (ens!3 thiss!2)) (@ (f!190 (f!193 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (forall ((x!56 B!27)) (@ (f!190 (fun1!23 (pre!96 (ens!3 (as thiss!2 (~>!5 A!35 B!27)))) (lambda ((x!295 B!27)) true))) x!56)) (@ (f!190 (fun1!23 (pre!96 (fun1!23 (pre!96 (f!193 (as thiss!2 (~>!5 A!35 B!27)))) (lambda ((x!296 A!35)) true))) (lambda ((x!297 A!35)) true))) (as x!57 A!35))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-90.tip

(declare-datatypes () ((List!54 (Cons!96 (head!143 (_ BitVec 32)) (tail!149 List!54)) (Nil!96))))

(declare-datatypes () ((AbsQueue!15 (Queue!15 (front!22 List!54) (rear!21 List!54)))))

(declare-const queue!2 AbsQueue!15)

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-91.tip

(declare-datatypes () ((KeyValuePairAbs!1 (KeyValuePair!1 (key!9 (_ BitVec 32)) (value!39 (_ BitVec 32))))))

(declare-datatypes () ((List!56 (Cons!98 (head!145 KeyValuePairAbs!1) (tail!151 List!56)) (Nil!98))))

(declare-const l2!11 List!56)

(declare-const l1!13 List!56)

(define-fun-rec domain!0 ((l!23 List!56)) (Set (_ BitVec 32)) (ite (is-Nil!98 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!9 (head!145 l!23))) (domain!0 (tail!151 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!56) (e!6 KeyValuePairAbs!1)) List!56 (let ((res!41 (ite (is-Nil!98 l!26) (Cons!98 e!6 Nil!98) (ite (= (key!9 e!6) (key!9 (head!145 l!26))) (Cons!98 (KeyValuePair!1 (key!9 e!6) (value!39 e!6)) (tail!151 l!26)) (Cons!98 (KeyValuePair!1 (key!9 (head!145 l!26)) (value!39 (head!145 l!26))) (updateElem!0 (tail!151 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!9 e!6)))) res!41)))

(define-fun-rec updateAll!0 ((l1!13 List!56) (l2!11 List!56)) List!56 (let ((x$1!12 (ite (is-Nil!98 l2!11) l1!13 (updateAll!0 (updateElem!0 l1!13 (head!145 l2!11)) (tail!151 l2!11))))) (assume (= (domain!0 x$1!12) (union (domain!0 l1!13) (domain!0 l2!11))) x$1!12)))

(assert (not (let ((x$1!82 (ite (is-Nil!98 l2!11) l1!13 (updateAll!0 (updateElem!0 l1!13 (head!145 l2!11)) (tail!151 l2!11))))) (= (domain!0 x$1!82) (union (domain!0 l1!13) (domain!0 l2!11))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-92.tip

(declare-datatypes () ((KeyValuePairAbs!2 (KeyValuePair!2 (key!10 (_ BitVec 32)) (value!40 (_ BitVec 32))))))

(declare-datatypes () ((List!57 (Cons!99 (head!146 KeyValuePairAbs!2) (tail!152 List!57)) (Nil!99))))

(declare-const l!26 List!57)

(declare-const e!6 KeyValuePairAbs!2)

(define-fun-rec domain!0 ((l!23 List!57)) (Set (_ BitVec 32)) (ite (is-Nil!99 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!10 (head!146 l!23))) (domain!0 (tail!152 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!57) (e!6 KeyValuePairAbs!2)) List!57 (let ((res!41 (ite (is-Nil!99 l!26) (Cons!99 e!6 Nil!99) (ite (= (key!10 e!6) (key!10 (head!146 l!26))) (Cons!99 (KeyValuePair!2 (key!10 e!6) (value!40 e!6)) (tail!152 l!26)) (Cons!99 (KeyValuePair!2 (key!10 (head!146 l!26)) (value!40 (head!146 l!26))) (updateElem!0 (tail!152 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!10 e!6)))) res!41)))

(assert (not (let ((res!328 (ite (is-Nil!99 l!26) (Cons!99 e!6 Nil!99) (ite (= (key!10 e!6) (key!10 (head!146 l!26))) (Cons!99 (KeyValuePair!2 (key!10 e!6) (value!40 e!6)) (tail!152 l!26)) (Cons!99 (KeyValuePair!2 (key!10 (head!146 l!26)) (value!40 (head!146 l!26))) (updateElem!0 (tail!152 l!26) e!6)))))) (= (domain!0 res!328) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!10 e!6)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-93.tip

(declare-datatypes () ((List!58 (Cons!100 (head!147 (_ BitVec 32)) (tail!153 List!58)) (Nil!100))))

(declare-datatypes () ((AbsQueue!17 (Queue!17 (front!24 List!58) (rear!23 List!58)))))

(define-fun-rec size!2 ((list!0 List!58)) Int (let ((x$1!6 (ite (is-Nil!100 list!0) 0 (+ 1 (size!2 (tail!153 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!58)) (Set (_ BitVec 32)) (ite (is-Nil!100 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!147 l!21)) (content!4 (tail!153 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!58) (l2!10 List!58)) List!58 (let ((res!35 (ite (is-Nil!100 l1!12) l2!10 (Cons!100 (head!147 l1!12) (concat!0 (tail!153 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!58)) List!58 (let ((x$2!4 (ite (is-Nil!100 l!22) Nil!100 (concat!0 (reverse!1 (tail!153 l!22)) (Cons!100 (head!147 l!22) Nil!100))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!17)) Bool (>= (size!2 (front!24 queue!1)) (size!2 (rear!23 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!58) (rear!3 List!58)) AbsQueue!17 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!17 front!3 rear!3) (Queue!17 (concat!0 front!3 (reverse!1 rear!3)) Nil!100)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(declare-const queue!3 AbsQueue!17)

(declare-const elem!1 (_ BitVec 32))

(assert (not (let ((x$4!11 (amortizedQueue!0 (front!24 queue!3) (Cons!100 elem!1 (rear!23 queue!3))))) (isAmortized!0 x$4!11))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-94.tip

(declare-datatypes (A0!3 A1!319) ((tuple2!2 (tuple2!3 (_1!1 A0!3) (_2!1 A1!319)))))

(declare-datatypes () ((Num!1 (Succ!2 (pred!1 Num!1)) (Zero!2))))

(declare-datatypes () ((Wrapper!1 (Wrapper!2 (num!3 Num!1)))))

(define-fun zipWrap!0 ((w1!0 Wrapper!1) (w2!0 Wrapper!1)) (tuple2!2 Wrapper!1 Wrapper!1) (tuple2!3 w1!0 w2!0))

(define-fun boolToNum!0 ((b!21 Bool)) Num!1 (ite b!21 Zero!2 (Succ!2 Zero!2)))

(declare-const b!22 Bool)

(assert (not (let ((x$1!14 (tuple2!3 (_1!1 (zipWrap!0 (Wrapper!2 (boolToNum!0 b!22)) (Wrapper!2 (boolToNum!0 (not b!22))))) (_2!1 (zipWrap!0 (Wrapper!2 (boolToNum!0 b!22)) (Wrapper!2 (boolToNum!0 (not b!22)))))))) (let ((z2!0 (_2!1 x$1!14))) (or (= (num!3 (_1!1 x$1!14)) Zero!2) (= (num!3 z2!0) Zero!2))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-95.tip

(declare-datatypes () ((List!62 (Cons!104 (head!151 (_ BitVec 32)) (tail!157 List!62)) (Nil!104))))

(declare-datatypes () ((AbsQueue!19 (Queue!19 (front!26 List!62) (rear!25 List!62)))))

(declare-const queue!0 AbsQueue!19)

(assert (not (is-Queue!19 queue!0)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-96.tip

(declare-datatypes () ((List!63 (Cons!105 (head!152 (_ BitVec 32)) (tail!158 List!63)) (Nil!105))))

(declare-datatypes () ((AbsQueue!20 (Queue!20 (front!27 List!63) (rear!26 List!63)))))

(declare-const queue!3 AbsQueue!20)

(assert (not (is-Queue!20 queue!3)))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-97.tip

(declare-datatypes () ((List!66 (Cons!108 (head!155 (_ BitVec 32)) (tail!161 List!66)) (Nil!108))))

(declare-datatypes () ((AbsQueue!23 (Queue!23 (front!30 List!66) (rear!29 List!66)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!23)) Bool (ite (and (is-Queue!23 queue!2) (is-Nil!108 (front!30 queue!2)) (is-Nil!108 (rear!29 queue!2))) true false))

(declare-const queue!8 AbsQueue!23)

(define-fun-rec size!2 ((list!0 List!66)) Int (let ((x$1!6 (ite (is-Nil!108 list!0) 0 (+ 1 (size!2 (tail!161 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!66)) (Set (_ BitVec 32)) (ite (is-Nil!108 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!155 l!21)) (content!4 (tail!161 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!66) (l2!10 List!66)) List!66 (let ((res!35 (ite (is-Nil!108 l1!12) l2!10 (Cons!108 (head!155 l1!12) (concat!0 (tail!161 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!66)) List!66 (let ((x$2!4 (ite (is-Nil!108 l!22) Nil!108 (concat!0 (reverse!1 (tail!161 l!22)) (Cons!108 (head!155 l!22) Nil!108))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!23)) Bool (>= (size!2 (front!30 queue!1)) (size!2 (rear!29 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!66) (rear!3 List!66)) AbsQueue!23 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!23 front!3 rear!3) (Queue!23 (concat!0 front!3 (reverse!1 rear!3)) Nil!108)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!23) (elem!1 (_ BitVec 32))) AbsQueue!23 (let ((x$4!1 (amortizedQueue!0 (front!30 queue!3) (Cons!108 elem!1 (rear!29 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (and (isAmortized!0 q3!0) (not (isEmpty!2 q3!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-98.tip

(declare-datatypes () ((List!68 (Cons!110 (head!157 (_ BitVec 32)) (tail!163 List!68)) (Nil!110))))

(define-fun-rec size!2 ((list!0 List!68)) Int (let ((x$1!6 (ite (is-Nil!110 list!0) 0 (+ 1 (size!2 (tail!163 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(declare-const rear!3 List!68)

(declare-const front!3 List!68)

(declare-datatypes () ((AbsQueue!25 (Queue!25 (front!32 List!68) (rear!31 List!68)))))

(define-fun-rec content!4 ((l!21 List!68)) (Set (_ BitVec 32)) (ite (is-Nil!110 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!157 l!21)) (content!4 (tail!163 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!68) (l2!10 List!68)) List!68 (let ((res!35 (ite (is-Nil!110 l1!12) l2!10 (Cons!110 (head!157 l1!12) (concat!0 (tail!163 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!68)) List!68 (let ((x$2!4 (ite (is-Nil!110 l!22) Nil!110 (concat!0 (reverse!1 (tail!163 l!22)) (Cons!110 (head!157 l!22) Nil!110))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!25)) Bool (>= (size!2 (front!32 queue!1)) (size!2 (rear!31 queue!1))))

(assert (not (let ((x$3!16 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!25 front!3 rear!3) (Queue!25 (concat!0 front!3 (reverse!1 rear!3)) Nil!110)))) (isAmortized!0 x$3!16))))

(check-sat)

; check-assumptions required here, but not part of tip standard

AbstractRefinementMap.scala-99.tip

(declare-datatypes (A1!271 A2!189 R!294) ((fun2!43 (fun2!44 (f!545 (=> A1!271 A2!189 R!294)) (pre!376 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!43 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!43 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!43 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!545 f!31) (@ (f!545 f!31) x!76 y!8) z!9) (@ (f!545 f!31) x!76 (@ (f!545 f!31) y!8 z!9)))))))

(declare-datatypes (A0!6 A1!324) ((tuple2!8 (tuple2!9 (_1!4 A0!6) (_2!4 A1!324)))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!545 (fun2!44 (pre!376 (as f1!0 (fun2!43 A!41 A!41 A!41))) (lambda ((x!818 A!41) (x!819 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!545 (fun2!44 (pre!376 (as f2!1 (fun2!43 B!30 B!30 B!30))) (lambda ((x!820 B!30) (x!821 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!43 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!43 B!30 B!30 B!30)))) (let ((fp!0 (fun2!44 (lambda ((p1!0 (tuple2!8 A!41 B!30)) (p2!0 (tuple2!8 A!41 B!30))) (tuple2!9 (@ (f!545 (as f1!0 (fun2!43 A!41 A!41 A!41))) (_1!4 p1!0) (_1!4 p2!0)) (@ (f!545 (as f2!1 (fun2!43 B!30 B!30 B!30))) (_2!4 p1!0) (_2!4 p2!0)))) (lambda ((p1!9 (tuple2!8 A!41 B!30)) (p2!11 (tuple2!8 A!41 B!30))) (and (@ (f!545 (fun2!44 (pre!376 (as f1!0 (fun2!43 A!41 A!41 A!41))) (lambda ((x!822 A!41) (x!823 A!41)) true))) (_1!4 p1!9) (_1!4 p2!11)) (@ (f!545 (fun2!44 (pre!376 (as f2!1 (fun2!43 B!30 B!30 B!30))) (lambda ((x!824 B!30) (x!825 B!30)) true))) (_2!4 p1!9) (_2!4 p2!11))))))) (isAssociative!0 fp!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard

gistfile1.txt

(declare-datatypes (A1!36 R!59) ((fun1!8 (fun1!10 (f!148 (=> A1!36 R!59)) (pre!89 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!1 (Positive!2 (i!53 Int)))))

(declare-const f!28 (fun1!8 Positive!1 Positive!1))

(datatype-invariant thiss!1 Positive!1 (> (i!53 thiss!1) 0))

(assert (not (=> (@ (f!148 (fun1!10 (pre!89 f!28) (lambda ((x!187 Positive!1)) true))) (Positive!2 1)) (let ((res!102 (@ (f!148 f!28) (Positive!2 1)))) (> (i!53 res!102) 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!73 (Cons!18 (head!32 Int) (tail!37 A!73)) (Nil!18 (i!51 Int)))))

(declare-const a!18 A!73)

(define-fun-rec sum!0 ((a!18 A!73)) Int (let ((i!16 (ite (is-Cons!18 a!18) (+ (head!32 a!18) (sum!0 (tail!37 a!18))) (i!51 a!18)))) (assume (>= i!16 0) i!16)))

(define-fun inv!5 ((thiss!6 A!73)) Bool (>= (i!51 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!73)) Int (assume (or (is-Cons!18 thiss!5) (is-Nil!18 thiss!5)) (let ((i!14 (ite (is-Cons!18 thiss!5) (+ 1 (size!1 (tail!37 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!73)) Bool (ite (is-Nil!18 thiss!8) (inv!5 (assume (is-Nil!18 thiss!8) thiss!8)) (ite (is-Cons!18 thiss!8) (= (head!32 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!73 (inv!4 (assume true thiss!3)))

(assert (not (let ((i!46 (ite (is-Cons!18 a!18) (+ (head!32 a!18) (sum!0 (tail!37 a!18))) (i!51 a!18)))) (>= i!46 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Pos!1 (Pos!2 (i!52 Int)))))

(declare-const p!23 Pos!1)

(datatype-invariant thiss!0 Pos!1 (> (i!52 thiss!0) 0))

(assert (not (> (i!52 (Pos!2 (+ (i!52 p!23) 1))) 0)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!9 (fun1!11 (f!149 (=> A1!50 R!72)) (pre!90 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!1 (~>!2 (f!152 (fun1!9 A!30 B!20)) (ens!1 (fun1!9 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!1 A!35 B!27))))

(declare-const (par (B!27) (x!56 B!27)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!1 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!149 (fun1!11 (pre!90 (ens!1 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!149 (fun1!11 (pre!90 (f!152 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!149 (ens!1 thiss!2)) (@ (f!149 (f!152 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (@ (f!149 (fun1!11 (pre!90 (fun1!11 (pre!90 (ens!1 (as thiss!2 (~>!1 A!35 B!27)))) (lambda ((x!185 B!27)) true))) (lambda ((x!186 B!27)) true))) (as x!56 B!27)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!63) ((array!16 (array!19 (arr!9 (Array (_ BitVec 32) A!63)) (size!27 (_ BitVec 32))))))

(declare-datatypes () ((A1!88 (A1!89 (x!209 (_ BitVec 32))))))

(declare-datatypes () ((B!40 (B!41 (t!70 (array!16 A1!88))))))

(declare-const b!13 B!40)

(datatype-invariant (par (A!49) array!7 (array!16 A!49) (bvsge (size!27 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!27 (t!70 b!13)) #b00000000000000000000000000000000) (bvsgt (x!209 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!27 (t!70 b!13)))) (select (arr!9 (t!70 b!13)) #b00000000000000000000000000000000))) #b00000000000000000000000000000000)) (let ((a!41 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!27 (t!70 b!13)))) (select (arr!9 (t!70 b!13)) #b00000000000000000000000000000000)))) (bvsge (x!209 a!41) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!63 Int)

(declare-const y!6 Int)

(assert (not (=> (and (>= x!63 0) (>= y!6 0)) (let ((x$1!23 (+ x!63 y!6))) (>= x$1!23 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!62 Int)

(declare-datatypes () ((Acc!3 (Acc!4 (checking!1 Int) (savings!1 Int)))))

(define-fun notRed!0 ((a!17 Acc!3)) Bool (and (>= (checking!1 a!17) 0) (>= (savings!1 a!17) 0)))

(declare-const a!16 Acc!3)

(define-fun sameTotal!0 ((a1!0 Acc!3) (a2!0 Acc!3)) Bool (= (+ (checking!1 a1!0) (savings!1 a1!0)) (+ (checking!1 a2!0) (savings!1 a2!0))))

(assert (not (=> (and (and (> x!62 0) (notRed!0 a!16)) (>= (checking!1 a!16) x!62)) (let ((r!65 (Acc!4 (- (checking!1 a!16) x!62) (+ (savings!1 a!16) x!62)))) (and (notRed!0 r!65) (sameTotal!0 a!16 r!65))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!57) ((array!17 (array!18 (arr!10 (Array (_ BitVec 32) A!57)) (size!28 (_ BitVec 32))))))

(declare-datatypes () ((A1!86 (A1!87 (x!208 (_ BitVec 32))))))

(declare-datatypes () ((B!38 (B!39 (t!69 (array!17 A1!86))))))

(declare-const b!14 B!38)

(datatype-invariant (par (A!48) array!5 (array!17 A!48) (bvsge (size!28 array!5) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!28 (t!69 b!14)) #b00000000000000000000000000000010) (let ((a!40 (size!28 (t!69 b!14)))) (bvsgt a!40 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!63) ((array!28 (array!29 (arr!15 (Array (_ BitVec 32) A!63)) (size!35 (_ BitVec 32))))))

(declare-datatypes () ((A1!94 (A1!95 (x!294 (_ BitVec 32))))))

(declare-datatypes () ((B!55 (B!56 (t!85 (array!28 A1!94))))))

(declare-const b!13 B!55)

(datatype-invariant (par (A!49) array!7 (array!28 A!49) (bvsge (size!35 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!35 (t!85 b!13)) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!35 (t!85 b!13)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!22 (fun1!23 (f!190 (=> A1!50 R!72)) (pre!96 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!5 (~>!6 (f!193 (fun1!22 A!30 B!20)) (ens!3 (fun1!22 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!5 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!5 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!190 (fun1!23 (pre!96 (ens!3 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!190 (fun1!23 (pre!96 (f!193 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!190 (ens!3 thiss!2)) (@ (f!190 (f!193 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (forall ((x!56 B!27)) (@ (f!190 (fun1!23 (pre!96 (ens!3 (as thiss!2 (~>!5 A!35 B!27)))) (lambda ((x!295 B!27)) true))) x!56)) (@ (f!190 (fun1!23 (pre!96 (fun1!23 (pre!96 (f!193 (as thiss!2 (~>!5 A!35 B!27)))) (lambda ((x!296 A!35)) true))) (lambda ((x!297 A!35)) true))) (as x!57 A!35))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!63) ((array!34 (array!35 (arr!18 (Array (_ BitVec 32) A!63)) (size!38 (_ BitVec 32))))))

(declare-datatypes () ((A1!100 (A1!101 (x!306 (_ BitVec 32))))))

(declare-datatypes () ((B!63 (B!64 (t!87 (array!34 A1!100))))))

(declare-const b!13 B!63)

(datatype-invariant (par (A!49) array!7 (array!34 A!49) (bvsge (size!38 array!7) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!38 (t!87 b!13)) #b00000000000000000000000000000000) (bvsgt (x!306 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!38 (t!87 b!13)))) (select (arr!18 (t!87 b!13)) #b00000000000000000000000000000000))) #b00000000000000000000000000000000)) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!38 (t!87 b!13)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!36 R!59) ((fun1!32 (fun1!33 (f!198 (=> A1!36 R!59)) (pre!101 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!5 (Positive!6 (i!71 Int)))))

(declare-const f!28 (fun1!32 Positive!5 Positive!5))

(datatype-invariant thiss!1 Positive!5 (> (i!71 thiss!1) 0))

(assert (not (@ (f!198 (fun1!33 (pre!101 (fun1!33 (pre!101 f!28) (lambda ((x!312 Positive!5)) true))) (lambda ((x!313 Positive!5)) true))) (Positive!6 1))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Pos!5 (Pos!6 (i!69 Int)))))

(define-fun inv!3 ((thiss!0 Pos!5)) Bool (> (i!69 thiss!0) 0))

(declare-const p!23 Pos!5)

(datatype-invariant thiss!0 Pos!5 (> (i!69 thiss!0) 0))

(assert (not (inv!3 (Pos!6 (+ (i!69 p!23) 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Positive!9 (Positive!10 (i!75 Int)))))

(define-fun inv!2 ((thiss!1 Positive!9)) Bool (> (i!75 thiss!1) 0))

(datatype-invariant thiss!1 Positive!9 (> (i!75 thiss!1) 0))

(assert (not (inv!2 (Positive!10 1))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!17 (Cons!26 (h!62 T!0) (t!96 (List!17 T!0))) (Nil!26))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!17 T!29))) (Set T!29) (ite (is-Nil!26 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!62 thiss!4)) (content!0 (t!96 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!17 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!26 thiss!10) (or (= (h!62 thiss!10) v!0) (contains!0 (t!96 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!17 A!31))))

(declare-const (par (A!31) (x!60 A!31)))

(declare-datatypes (A1!50 R!72) ((fun1!38 (fun1!39 (f!201 (=> A1!50 R!72)) (pre!104 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!9 (~>!10 (f!204 (fun1!38 A!30 B!20)) (ens!5 (fun1!38 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!9 A!36 B!28))) (fun1!38 A!36 Bool) (fun1!39 (pre!104 (f!204 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!9 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!9 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!201 (fun1!39 (pre!104 (ens!5 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!201 (fun1!39 (pre!104 (f!204 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!201 (ens!5 thiss!2)) (@ (f!201 (f!204 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (contains!0 (as l!19 (List!17 A!31)) (as x!60 A!31)) (@ (f!201 (fun1!39 (pre!104 (pre!0 (as f!27 (~>!9 A!31 B!21)))) (lambda ((x!326 A!31)) true))) (as x!60 A!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!18 (Cons!27 (head!65 (_ BitVec 32)) (tail!71 List!18)) (Nil!27))))

(declare-datatypes () ((C!14 (C!15 (l!114 List!18)))))

(declare-const c!14 C!14)

(assert (not (is-Cons!27 (l!114 c!14))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!36 R!59) ((fun1!36 (fun1!37 (f!200 (=> A1!36 R!59)) (pre!103 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!13 (Positive!14 (i!77 Int)))))

(declare-const f!28 (fun1!36 Positive!13 Positive!13))

(datatype-invariant thiss!1 Positive!13 (> (i!77 thiss!1) 0))

(assert (not (=> (@ (f!200 (fun1!37 (pre!103 f!28) (lambda ((x!327 Positive!13)) true))) (Positive!14 1)) (@ (f!200 (fun1!37 (pre!103 f!28) (lambda ((x!328 Positive!13)) true))) (Positive!14 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!103 (Cons!30 (head!67 Int) (tail!73 A!103)) (Nil!30 (i!82 Int)))))

(declare-const thiss!8 A!103)

(define-fun inv!5 ((thiss!6 A!103)) Bool (>= (i!82 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!103)) Int (assume (or (is-Cons!30 thiss!5) (is-Nil!30 thiss!5)) (let ((i!14 (ite (is-Cons!30 thiss!5) (+ 1 (size!1 (tail!73 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!103)) Bool (ite (is-Nil!30 thiss!8) (inv!5 (assume (is-Nil!30 thiss!8) thiss!8)) (ite (is-Cons!30 thiss!8) (= (head!67 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!103 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (or (is-Cons!30 thiss!8) (is-Nil!30 thiss!8)) (is-Nil!30 thiss!8)) (is-Nil!30 thiss!8))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!50 (fun1!51 (f!209 (=> A1!50 R!72)) (pre!110 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!13 (~>!14 (f!212 (fun1!50 A!30 B!20)) (ens!7 (fun1!50 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!13 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!13 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!209 (fun1!51 (pre!110 (ens!7 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!209 (fun1!51 (pre!110 (f!212 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!209 (ens!7 thiss!2)) (@ (f!209 (f!212 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (and (forall ((x!56 B!27)) (@ (f!209 (fun1!51 (pre!110 (ens!7 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!337 B!27)) true))) x!56)) (@ (f!209 (fun1!51 (pre!110 (f!212 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!338 A!35)) true))) (as x!57 A!35))) (@ (f!209 (fun1!51 (pre!110 (f!212 (as thiss!2 (~>!13 A!35 B!27)))) (lambda ((x!339 A!35)) true))) (as x!57 A!35))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!36 R!59) ((fun1!56 (fun1!57 (f!214 (=> A1!36 R!59)) (pre!113 (=> A1!36 Bool))))))

(declare-datatypes () ((Positive!17 (Positive!18 (i!85 Int)))))

(declare-const f!28 (fun1!56 Positive!17 Positive!17))

(define-fun inv!2 ((thiss!1 Positive!17)) Bool (> (i!85 thiss!1) 0))

(datatype-invariant thiss!1 Positive!17 (> (i!85 thiss!1) 0))

(assert (not (=> (@ (f!214 (fun1!57 (pre!113 f!28) (lambda ((x!341 Positive!17)) true))) (Positive!18 1)) (inv!2 (Positive!18 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!66 (fun1!67 (f!222 (=> A1!50 R!72)) (pre!118 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!17 (~>!18 (f!225 (fun1!66 A!30 B!20)) (ens!9 (fun1!66 B!20 Bool))))))

(declare-const (par (A!35 B!27) (thiss!2 (~>!17 A!35 B!27))))

(declare-const (par (A!35) (x!57 A!35)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!17 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!222 (fun1!67 (pre!118 (ens!9 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!222 (fun1!67 (pre!118 (f!225 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!222 (ens!9 thiss!2)) (@ (f!222 (f!225 thiss!2)) x!57)))))))

(assert (par (B!27 A!35) (not (=> (and (forall ((x!56 B!27)) (@ (f!222 (fun1!67 (pre!118 (ens!9 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!349 B!27)) true))) x!56)) (@ (f!222 (fun1!67 (pre!118 (f!225 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!350 A!35)) true))) (as x!57 A!35))) (@ (f!222 (fun1!67 (pre!118 (ens!9 (as thiss!2 (~>!17 A!35 B!27)))) (lambda ((x!351 B!27)) true))) (@ (f!222 (f!225 (as thiss!2 (~>!17 A!35 B!27)))) (as x!57 A!35)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!111 (Cons!32 (head!69 Int) (tail!75 A!111)) (Nil!32 (i!90 Int)))))

(declare-const thiss!8 A!111)

(define-fun inv!5 ((thiss!6 A!111)) Bool (>= (i!90 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!111)) Int (assume (or (is-Cons!32 thiss!5) (is-Nil!32 thiss!5)) (let ((i!14 (ite (is-Cons!32 thiss!5) (+ 1 (size!1 (tail!75 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!111)) Bool (ite (is-Nil!32 thiss!8) (inv!5 (assume (is-Nil!32 thiss!8) thiss!8)) (ite (is-Cons!32 thiss!8) (= (head!69 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!111 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (is-Cons!32 thiss!8) (not (is-Nil!32 thiss!8))) (or (is-Cons!32 thiss!8) (is-Nil!32 thiss!8)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!117 (Cons!36 (head!73 Int) (tail!79 A!117)) (Nil!36 (i!92 Int)))))

(declare-const thiss!5 A!117)

(define-fun inv!5 ((thiss!6 A!117)) Bool (>= (i!92 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!117)) Int (assume (or (is-Cons!36 thiss!5) (is-Nil!36 thiss!5)) (let ((i!14 (ite (is-Cons!36 thiss!5) (+ 1 (size!1 (tail!79 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!117)) Bool (ite (is-Nil!36 thiss!8) (inv!5 (assume (is-Nil!36 thiss!8) thiss!8)) (ite (is-Cons!36 thiss!8) (= (head!73 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!117 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (or (is-Cons!36 thiss!5) (is-Nil!36 thiss!5)) (is-Cons!36 thiss!5)) (let ((h!47 (head!73 thiss!5))) (let ((t!54 (tail!79 thiss!5))) (or (is-Cons!36 t!54) (is-Nil!36 t!54)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!119 (Cons!38 (head!75 Int) (tail!81 A!119)) (Nil!38 (i!95 Int)))))

(declare-const a!18 A!119)

(define-fun inv!5 ((thiss!6 A!119)) Bool (>= (i!95 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!119)) Int (assume (or (is-Cons!38 thiss!5) (is-Nil!38 thiss!5)) (let ((i!14 (ite (is-Cons!38 thiss!5) (+ 1 (size!1 (tail!81 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!119)) Bool (ite (is-Nil!38 thiss!8) (inv!5 (assume (is-Nil!38 thiss!8) thiss!8)) (ite (is-Cons!38 thiss!8) (= (head!75 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!119 (inv!4 (assume true thiss!3)))

(assert (not (or (is-Cons!38 a!18) (is-Nil!38 a!18))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!21 (Cons!39 (h!65 T!0) (t!98 (List!21 T!0))) (Nil!39))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!21 T!29))) (Set T!29) (ite (is-Nil!39 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!65 thiss!4)) (content!0 (t!98 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!21 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!39 thiss!10) (or (= (h!65 thiss!10) v!0) (contains!0 (t!98 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!21 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!76 (fun1!77 (f!231 (=> A1!50 R!72)) (pre!123 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!21 (~>!22 (f!234 (fun1!76 A!30 B!20)) (ens!11 (fun1!76 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!21 A!36 B!28))) (fun1!76 A!36 Bool) (fun1!77 (pre!123 (f!234 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!21 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!21 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!231 (fun1!77 (pre!123 (ens!11 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!231 (fun1!77 (pre!123 (f!234 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!231 (ens!11 thiss!2)) (@ (f!231 (f!234 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (and (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!21 A!31)) x!60) (@ (f!231 (pre!0 (as f!27 (~>!21 A!31 B!21)))) x!60))) (is-Cons!39 (as l!19 (List!21 A!31)))) (let ((x!61 (h!65 (as l!19 (List!21 A!31))))) (let ((xs!22 (t!98 (as l!19 (List!21 A!31))))) (@ (f!231 (fun1!77 (pre!123 (f!234 (as f!27 (~>!21 A!31 B!21)))) (lambda ((x!371 A!31)) true))) x!61)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!121 (Cons!41 (head!77 Int) (tail!83 A!121)) (Nil!41 (i!97 Int)))))

(declare-const thiss!5 A!121)

(define-fun-rec size!1 ((thiss!5 A!121)) Int (assume (or (is-Cons!41 thiss!5) (is-Nil!41 thiss!5)) (let ((i!14 (ite (is-Cons!41 thiss!5) (+ 1 (size!1 (tail!83 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!5 ((thiss!6 A!121)) Bool (>= (i!97 thiss!6) 0))

(define-fun inv!4 ((thiss!8 A!121)) Bool (ite (is-Nil!41 thiss!8) (inv!5 (assume (is-Nil!41 thiss!8) thiss!8)) (ite (is-Cons!41 thiss!8) (= (head!77 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!121 (inv!4 (assume true thiss!3)))

(assert (not (=> (or (is-Cons!41 thiss!5) (is-Nil!41 thiss!5)) (let ((i!45 (ite (is-Cons!41 thiss!5) (+ 1 (size!1 (tail!83 thiss!5))) 0))) (>= i!45 0)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!125 (Cons!43 (head!79 Int) (tail!85 A!125)) (Nil!43 (i!99 Int)))))

(declare-const thiss!3 A!125)

(define-fun inv!5 ((thiss!6 A!125)) Bool (>= (i!99 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!125)) Int (assume (or (is-Cons!43 thiss!5) (is-Nil!43 thiss!5)) (let ((i!14 (ite (is-Cons!43 thiss!5) (+ 1 (size!1 (tail!85 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!125)) Bool (ite (is-Nil!43 thiss!8) (inv!5 (assume (is-Nil!43 thiss!8) thiss!8)) (ite (is-Cons!43 thiss!8) (= (head!79 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!125 (inv!4 (assume true thiss!3)))

(assert (not (or (is-Cons!43 (assume true thiss!3)) (is-Nil!43 (assume true thiss!3)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!24 (Cons!48 (h!67 T!0) (t!100 (List!24 T!0))) (Nil!48))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!24 T!29))) (Set T!29) (ite (is-Nil!48 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!67 thiss!4)) (content!0 (t!100 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!24 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!48 thiss!10) (or (= (h!67 thiss!10) v!0) (contains!0 (t!100 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!24 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!87 (fun1!88 (f!253 (=> A1!50 R!72)) (pre!139 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!25 (~>!26 (f!256 (fun1!87 A!30 B!20)) (ens!13 (fun1!87 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!25 A!36 B!28))) (fun1!87 A!36 Bool) (fun1!88 (pre!139 (f!256 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!25 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!25 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!253 (fun1!88 (pre!139 (ens!13 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!253 (fun1!88 (pre!139 (f!256 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!253 (ens!13 thiss!2)) (@ (f!253 (f!256 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (and (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!24 A!31)) x!60) (@ (f!253 (pre!0 (as f!27 (~>!25 A!31 B!21)))) x!60))) (is-Cons!48 (as l!19 (List!24 A!31)))) (let ((x!61 (h!67 (as l!19 (List!24 A!31))))) (let ((xs!22 (t!100 (as l!19 (List!24 A!31))))) (forall ((x!60 A!31)) (=> (contains!0 xs!22 x!60) (@ (f!253 (pre!0 (as f!27 (~>!25 A!31 B!21)))) x!60)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!136 (Cons!49 (head!96 Int) (tail!101 A!136)) (Nil!49 (i!103 Int)))))

(declare-const thiss!8 A!136)

(define-fun inv!5 ((thiss!6 A!136)) Bool (>= (i!103 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!136)) Int (assume (or (is-Cons!49 thiss!5) (is-Nil!49 thiss!5)) (let ((i!14 (ite (is-Cons!49 thiss!5) (+ 1 (size!1 (tail!101 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!136)) Bool (ite (is-Nil!49 thiss!8) (inv!5 (assume (is-Nil!49 thiss!8) thiss!8)) (ite (is-Cons!49 thiss!8) (= (head!96 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!136 (inv!4 (assume true thiss!3)))

(assert (not (=> (and (is-Cons!49 thiss!8) (not (is-Nil!49 thiss!8))) (let ((h!46 (head!96 thiss!8))) (let ((t!53 (tail!101 thiss!8))) (or (is-Cons!49 thiss!8) (is-Nil!49 thiss!8)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!138 (A!139 (x!399 (_ BitVec 32))))))

(declare-datatypes (A!133) ((array!44 (array!45 (arr!23 (Array (_ BitVec 32) A!133)) (size!47 (_ BitVec 32))))))

(declare-datatypes () ((B!92 (B!93 (a!89 (array!44 A!138))))))

(datatype-invariant (par (A!132) array!41 (array!44 A!132) (bvsge (size!47 array!41) #b00000000000000000000000000000000)))

(assert (not (let ((b!118 (B!93 (array!45 (store (store (store ((as const (Array (_ BitVec 32) A!138)) (A!139 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!139 #b00000000000000000000000000000001)) #b00000000000000000000000000000001 (A!139 #b00000000000000000000000000000010)) #b00000000000000000000000000000010 (A!139 #b00000000000000000000000000000011)) #b00000000000000000000000000000011)))) (bvsgt (size!47 (a!89 b!118)) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!144 (Cons!52 (head!101 Int) (tail!106 A!144)) (Nil!52 (i!105 Int)))))

(declare-const thiss!5 A!144)

(define-fun inv!5 ((thiss!6 A!144)) Bool (>= (i!105 thiss!6) 0))

(define-fun-rec size!1 ((thiss!5 A!144)) Int (assume (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)) (let ((i!14 (ite (is-Cons!52 thiss!5) (+ 1 (size!1 (tail!106 thiss!5))) 0))) (assume (>= i!14 0) i!14))))

(define-fun inv!4 ((thiss!8 A!144)) Bool (ite (is-Nil!52 thiss!8) (inv!5 (assume (is-Nil!52 thiss!8) thiss!8)) (ite (is-Cons!52 thiss!8) (= (head!101 thiss!8) (size!1 thiss!8)) true)))

(datatype-invariant thiss!3 A!144 (inv!4 (assume true thiss!3)))

(assert (not (=> (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)) (or (is-Cons!52 thiss!5) (is-Nil!52 thiss!5)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!146 (A!147 (x!411 (_ BitVec 32))))))

(declare-datatypes (A!133) ((array!50 (array!51 (arr!26 (Array (_ BitVec 32) A!133)) (size!50 (_ BitVec 32))))))

(declare-datatypes () ((B!96 (B!97 (a!91 (array!50 A!146))))))

(define-fun foo!0 ((b!15 B!96)) (_ BitVec 32) (x!411 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!50 (a!91 b!15)))) (select (arr!26 (a!91 b!15)) #b00000000000000000000000000000000))))

(datatype-invariant (par (A!132) array!41 (array!50 A!132) (bvsge (size!50 array!41) #b00000000000000000000000000000000)))

(assert (not (let ((b!118 (B!97 (array!51 (store (store (store ((as const (Array (_ BitVec 32) A!146)) (A!147 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!147 #b00000000000000000000000000000001)) #b00000000000000000000000000000001 (A!147 #b00000000000000000000000000000010)) #b00000000000000000000000000000010 (A!147 #b00000000000000000000000000000011)) #b00000000000000000000000000000011)))) (let ((x$1!69 (foo!0 b!118))) (= x$1!69 #b00000000000000000000000000000001)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!27 (Cons!55 (h!70 T!0) (t!103 (List!27 T!0))) (Nil!55))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!27 T!29))) (Set T!29) (ite (is-Nil!55 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!70 thiss!4)) (content!0 (t!103 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!27 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!55 thiss!10) (or (= (h!70 thiss!10) v!0) (contains!0 (t!103 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!27 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!100 (fun1!101 (f!274 (=> A1!50 R!72)) (pre!156 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!29 (~>!30 (f!277 (fun1!100 A!30 B!20)) (ens!15 (fun1!100 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!29 A!36 B!28))) (fun1!100 A!36 Bool) (fun1!101 (pre!156 (f!277 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!29 A!31 B!21))))

(define-fun (par (A!37 B!29) (apply!2 ((thiss!9 (~>!29 A!37 B!29)) (x!58 A!37)) B!29 (assume (@ (f!274 (fun1!101 (pre!156 (f!277 thiss!9)) (lambda ((x!163 A!37)) true))) x!58) (let ((res!31 (@ (f!274 (f!277 thiss!9)) x!58))) (assume (@ (f!274 (ens!15 thiss!9)) res!31) res!31))))))

(define-fun-rec (par (A!31 B!21) (map!4 ((l!19 (List!27 A!31)) (f!27 (~>!29 A!31 B!21))) (List!27 B!21) (assume (forall ((x!60 A!31)) (=> (contains!0 l!19 x!60) (@ (f!274 (pre!0 f!27)) x!60))) (let ((res!32 (ite (is-Cons!55 l!19) (Cons!55 (apply!2 f!27 (h!70 l!19)) (map!4 (t!103 l!19) f!27)) (as Nil!55 (List!27 B!21))))) (assume (forall ((x!59 B!21)) (=> (contains!0 res!32 x!59) (@ (f!274 (ens!15 f!27)) x!59))) res!32))))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!29 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!274 (fun1!101 (pre!156 (ens!15 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!274 (fun1!101 (pre!156 (f!277 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!274 (ens!15 thiss!2)) (@ (f!274 (f!277 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!27 A!31)) x!60) (@ (f!274 (pre!0 (as f!27 (~>!29 A!31 B!21)))) x!60))) (let ((res!104 (ite (is-Cons!55 (as l!19 (List!27 A!31))) (Cons!55 (apply!2 (as f!27 (~>!29 A!31 B!21)) (h!70 (as l!19 (List!27 A!31)))) (map!4 (t!103 (as l!19 (List!27 A!31))) (as f!27 (~>!29 A!31 B!21)))) (as Nil!55 (List!27 B!21))))) (forall ((x!59 B!21)) (=> (contains!0 res!104 x!59) (@ (f!274 (ens!15 (as f!27 (~>!29 A!31 B!21)))) x!59))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!160 (A!161 (x!420 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!56 (array!57 (arr!29 (Array (_ BitVec 32) A!149)) (size!53 (_ BitVec 32))))))

(declare-datatypes () ((B!102 (B!103 (content!13 (array!56 A!160))))))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!56 A!148) (bvsge (size!53 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!102 (bvsgt (size!53 (content!13 thiss!45)) #b00000000000000000000000000000000))

(assert (not (let ((res!180 (B!103 (array!57 (store ((as const (Array (_ BitVec 32) A!160)) (A!161 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!161 y!7)) #b00000000000000000000000000000001)))) (= (x!420 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!53 (content!13 res!180)))) (select (arr!29 (content!13 res!180)) #b00000000000000000000000000000000))) y!7))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!30 (Cons!58 (h!72 T!0) (t!105 (List!30 T!0))) (Nil!58))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!30 T!29))) (Set T!29) (ite (is-Nil!58 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!72 thiss!4)) (content!0 (t!105 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!30 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!58 thiss!10) (or (= (h!72 thiss!10) v!0) (contains!0 (t!105 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!30 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!111 (fun1!112 (f!295 (=> A1!50 R!72)) (pre!172 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!33 (~>!34 (f!300 (fun1!111 A!30 B!20)) (ens!17 (fun1!111 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!33 A!36 B!28))) (fun1!111 A!36 Bool) (fun1!112 (pre!172 (f!300 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!33 A!31 B!21))))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!33 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!295 (fun1!112 (pre!172 (ens!17 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!295 (fun1!112 (pre!172 (f!300 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!295 (ens!17 thiss!2)) (@ (f!295 (f!300 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!30 A!31)) x!60) (@ (f!295 (pre!0 (as f!27 (~>!33 A!31 B!21)))) x!60))) (or (is-Cons!58 (as l!19 (List!30 A!31))) (is-Nil!58 (as l!19 (List!30 A!31))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const index!2 (_ BitVec 32))

(declare-datatypes (A!165) ((array!60 (array!61 (arr!31 (Array (_ BitVec 32) A!165)) (size!55 (_ BitVec 32))))))

(declare-datatypes () ((HashTable!1 (HashTable!2 (table!1 (array!60 Int))))))

(declare-const thiss!44 HashTable!1)

(datatype-invariant (par (A!164) array!59 (array!60 A!164) (bvsge (size!55 array!59) #b00000000000000000000000000000000)))

(datatype-invariant thiss!43 HashTable!1 (bvsgt (size!55 (table!1 thiss!43)) #b00000000000000000000000000000000))

(assert (not (=> (and (bvsge index!2 #b00000000000000000000000000000000) (bvslt index!2 (size!55 (table!1 thiss!44)))) (and (bvsge index!2 #b00000000000000000000000000000000) (bvslt index!2 (size!55 (table!1 thiss!44)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!133) ((array!68 (array!69 (arr!35 (Array (_ BitVec 32) A!133)) (size!59 (_ BitVec 32))))))

(declare-datatypes () ((A!179 (A!180 (x!446 (_ BitVec 32))))))

(declare-datatypes () ((B!113 (B!114 (a!107 (array!68 A!179))))))

(declare-const b!15 B!113)

(datatype-invariant (par (A!132) array!41 (array!68 A!132) (bvsge (size!59 array!41) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!59 (a!107 b!15)) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!59 (a!107 b!15)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!123 (fun1!124 (f!309 (=> A1!50 R!72)) (pre!178 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!37 (~>!38 (f!312 (fun1!123 A!30 B!20)) (ens!19 (fun1!123 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!37 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!37 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!309 (fun1!124 (pre!178 (ens!19 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!309 (fun1!124 (pre!178 (f!312 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!309 (ens!19 thiss!2)) (@ (f!309 (f!312 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!309 (fun1!124 (pre!178 (f!312 (as thiss!9 (~>!37 A!37 B!29)))) (lambda ((x!445 A!37)) true))) (as x!58 A!37)) (let ((res!103 (@ (f!309 (f!312 (as thiss!9 (~>!37 A!37 B!29)))) (as x!58 A!37)))) (@ (f!309 (ens!19 (as thiss!9 (~>!37 A!37 B!29)))) res!103))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (T!0) ((List!33 (Cons!61 (h!75 T!0) (t!108 (List!33 T!0))) (Nil!61))))

(define-fun-rec (par (T!29) (content!0 ((thiss!4 (List!33 T!29))) (Set T!29) (ite (is-Nil!61 thiss!4) (as emptyset T!29) (union (insert (as emptyset T!29) (h!75 thiss!4)) (content!0 (t!108 thiss!4)))))))

(define-fun-rec (par (T!30) (contains!0 ((thiss!10 (List!33 T!30)) (v!0 T!30)) Bool (let ((x$2!0 (ite (is-Cons!61 thiss!10) (or (= (h!75 thiss!10) v!0) (contains!0 (t!108 thiss!10) v!0)) false))) (assume (= x$2!0 (member v!0 (content!0 thiss!10))) x$2!0)))))

(declare-const (par (A!31) (l!19 (List!33 A!31))))

(declare-datatypes (A1!50 R!72) ((fun1!157 (fun1!158 (f!344 (=> A1!50 R!72)) (pre!195 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!49 (~>!50 (f!347 (fun1!157 A!30 B!20)) (ens!25 (fun1!157 B!20 Bool))))))

(define-fun (par (A!36 B!28) (pre!0 ((thiss!7 (~>!49 A!36 B!28))) (fun1!157 A!36 Bool) (fun1!158 (pre!195 (f!347 thiss!7)) (lambda ((x!162 A!36)) true)))))

(declare-const (par (A!31 B!21) (f!27 (~>!49 A!31 B!21))))

(define-fun (par (A!37 B!29) (apply!2 ((thiss!9 (~>!49 A!37 B!29)) (x!58 A!37)) B!29 (assume (@ (f!344 (fun1!158 (pre!195 (f!347 thiss!9)) (lambda ((x!163 A!37)) true))) x!58) (let ((res!31 (@ (f!344 (f!347 thiss!9)) x!58))) (assume (@ (f!344 (ens!25 thiss!9)) res!31) res!31))))))

(define-fun-rec (par (A!31 B!21) (map!4 ((l!19 (List!33 A!31)) (f!27 (~>!49 A!31 B!21))) (List!33 B!21) (assume (forall ((x!60 A!31)) (=> (contains!0 l!19 x!60) (@ (f!344 (pre!0 f!27)) x!60))) (let ((res!32 (ite (is-Cons!61 l!19) (Cons!61 (apply!2 f!27 (h!75 l!19)) (map!4 (t!108 l!19) f!27)) (as Nil!61 (List!33 B!21))))) (assume (forall ((x!59 B!21)) (=> (contains!0 res!32 x!59) (@ (f!344 (ens!25 f!27)) x!59))) res!32))))))

(declare-const (par (B!21) (x!59 B!21)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!49 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!344 (fun1!158 (pre!195 (ens!25 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!344 (fun1!158 (pre!195 (f!347 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!344 (ens!25 thiss!2)) (@ (f!344 (f!347 thiss!2)) x!57)))))))

(assert (par (A!31 B!21) (not (=> (forall ((x!60 A!31)) (=> (contains!0 (as l!19 (List!33 A!31)) x!60) (@ (f!344 (pre!0 (as f!27 (~>!49 A!31 B!21)))) x!60))) (let ((res!32 (ite (is-Cons!61 (as l!19 (List!33 A!31))) (Cons!61 (apply!2 (as f!27 (~>!49 A!31 B!21)) (h!75 (as l!19 (List!33 A!31)))) (map!4 (t!108 (as l!19 (List!33 A!31))) (as f!27 (~>!49 A!31 B!21)))) (as Nil!61 (List!33 B!21))))) (=> (contains!0 res!32 (as x!59 B!21)) (@ (f!344 (fun1!158 (pre!195 (ens!25 (as f!27 (~>!49 A!31 B!21)))) (lambda ((x!488 B!21)) true))) (as x!59 B!21))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!135 (fun1!136 (f!329 (=> A1!50 R!72)) (pre!184 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!41 (~>!42 (f!332 (fun1!135 A!30 B!20)) (ens!21 (fun1!135 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!41 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!41 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!329 (fun1!136 (pre!184 (ens!21 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!329 (fun1!136 (pre!184 (f!332 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!329 (ens!21 thiss!2)) (@ (f!329 (f!332 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!329 (fun1!136 (pre!184 (f!332 (as thiss!9 (~>!41 A!37 B!29)))) (lambda ((x!467 A!37)) true))) (as x!58 A!37)) (@ (f!329 (fun1!136 (pre!184 (f!332 (as thiss!9 (~>!41 A!37 B!29)))) (lambda ((x!468 A!37)) true))) (as x!58 A!37))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!141 (fun1!142 (f!333 (=> A1!50 R!72)) (pre!187 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!43 (~>!44 (f!336 (fun1!141 A!30 B!20)) (ens!22 (fun1!141 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!43 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!43 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!333 (fun1!142 (pre!187 (ens!22 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!333 (fun1!142 (pre!187 (f!336 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!333 (ens!22 thiss!2)) (@ (f!333 (f!336 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (@ (f!333 (fun1!142 (pre!187 (fun1!142 (pre!187 (f!336 (as thiss!9 (~>!43 A!37 B!29)))) (lambda ((x!469 A!37)) true))) (lambda ((x!470 A!37)) true))) (as x!58 A!37)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!191 (A!192 (x!471 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!78 (array!79 (arr!40 (Array (_ BitVec 32) A!149)) (size!64 (_ BitVec 32))))))

(declare-datatypes () ((B!127 (B!128 (content!15 (array!78 A!191))))))

(define-fun inv!7 ((thiss!45 B!127)) Bool (bvsgt (size!64 (content!15 thiss!45)) #b00000000000000000000000000000000))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!78 A!148) (bvsge (size!64 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!127 (bvsgt (size!64 (content!15 thiss!45)) #b00000000000000000000000000000000))

(assert (not (inv!7 (B!128 (array!79 (store ((as const (Array (_ BitVec 32) A!191)) (A!192 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!192 y!7)) #b00000000000000000000000000000001)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!205 (A!206 (x!504 (_ BitVec 32))))))

(declare-datatypes (A!149) ((array!84 (array!85 (arr!43 (Array (_ BitVec 32) A!149)) (size!69 (_ BitVec 32))))))

(declare-datatypes () ((B!137 (B!138 (content!18 (array!84 A!205))))))

(declare-const y!7 (_ BitVec 32))

(datatype-invariant (par (A!148) array!47 (array!84 A!148) (bvsge (size!69 array!47) #b00000000000000000000000000000000)))

(datatype-invariant thiss!45 B!137 (bvsgt (size!69 (content!18 thiss!45)) #b00000000000000000000000000000000))

(assert (not (let ((res!34 (B!138 (array!85 (store ((as const (Array (_ BitVec 32) A!205)) (A!206 #b00000000000000000000000000000000)) #b00000000000000000000000000000000 (A!206 y!7)) #b00000000000000000000000000000001)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!69 (content!18 res!34)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!50 R!72) ((fun1!167 (fun1!168 (f!351 (=> A1!50 R!72)) (pre!200 (=> A1!50 Bool))))))

(declare-datatypes (A!30 B!20) ((~>!53 (~>!54 (f!354 (fun1!167 A!30 B!20)) (ens!27 (fun1!167 B!20 Bool))))))

(declare-const (par (A!37 B!29) (thiss!9 (~>!53 A!37 B!29))))

(declare-const (par (A!37) (x!58 A!37)))

(datatype-invariant (par (A!35 B!27) thiss!2 (~>!53 A!35 B!27) (and (forall ((x!56 B!27)) (@ (f!351 (fun1!168 (pre!200 (ens!27 thiss!2)) (lambda ((x!157 B!27)) true))) x!56)) (forall ((x!57 A!35)) (=> (@ (f!351 (fun1!168 (pre!200 (f!354 thiss!2)) (lambda ((x!159 A!35)) true))) x!57) (@ (f!351 (ens!27 thiss!2)) (@ (f!351 (f!354 thiss!2)) x!57)))))))

(assert (par (A!37 B!29) (not (=> (@ (f!351 (fun1!168 (pre!200 (f!354 (as thiss!9 (~>!53 A!37 B!29)))) (lambda ((x!520 A!37)) true))) (as x!58 A!37)) (let ((res!31 (@ (f!351 (f!354 (as thiss!9 (~>!53 A!37 B!29)))) (as x!58 A!37)))) (@ (f!351 (fun1!168 (pre!200 (ens!27 (as thiss!9 (~>!53 A!37 B!29)))) (lambda ((x!521 B!29)) true))) res!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!181 (fun1!182 (f!393 (=> A1!174 R!188)) (pre!228 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!182 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!129 Int)) true)))) (let ((res!259 (+ (@ (f!393 i!18) x!72) (@ (f!393 i!18) 2)))) (> res!259 0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!219) ((array!92 (array!93 (arr!47 (Array (_ BitVec 32) A!219)) (size!77 (_ BitVec 32))))))

(declare-const a!25 (array!92 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!92 A!218) (bvsge (size!77 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!77 a!25) #b00000000000000000000000000000010) (let ((res!258 (array!93 (store (arr!47 a!25) (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!77 a!25))) #b00000000000000000000000000000001) #b00000000000000000000000000000011) (size!77 a!25)))) (and (= (size!77 res!258) (size!77 a!25)) (= (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!77 res!258))) (select (arr!47 res!258) #b00000000000000000000000000000001)) #b00000000000000000000000000000011))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!225) ((array!102 (array!103 (arr!52 (Array (_ BitVec 32) A!225)) (size!82 (_ BitVec 32))))))

(datatype-invariant (par (A!224) array!97 (array!102 A!224) (bvsge (size!82 array!97) #b00000000000000000000000000000000)))

(assert (not (let ((a!126 (array!103 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000101) #b00000000000000000000000000000101))) (and (bvsgt (size!82 a!126) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!82 a!126))) (select (arr!52 a!126) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!219) ((array!98 (array!99 (arr!50 (Array (_ BitVec 32) A!219)) (size!80 (_ BitVec 32))))))

(declare-const a!25 (array!98 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!98 A!218) (bvsge (size!80 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!80 a!25) #b00000000000000000000000000000010) (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!80 a!25))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!184 (fun1!185 (f!407 (=> A1!174 R!188)) (pre!241 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!185 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!133 Int)) true)))) (@ (f!407 (fun1!185 (pre!241 i!18) (lambda ((x!621 Int)) true))) x!72)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!219) ((array!106 (array!107 (arr!54 (Array (_ BitVec 32) A!219)) (size!84 (_ BitVec 32))))))

(declare-const a!25 (array!106 (_ BitVec 32)))

(datatype-invariant (par (A!218) array!89 (array!106 A!218) (bvsge (size!84 array!89) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge (size!84 a!25) #b00000000000000000000000000000010) (let ((res!37 (array!107 (store (arr!54 a!25) (assume (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!84 a!25))) #b00000000000000000000000000000001) #b00000000000000000000000000000011) (size!84 a!25)))) (=> (= (size!84 res!37) (size!84 a!25)) (and (bvsge #b00000000000000000000000000000001 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000001 (size!84 res!37))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!72 Int)

(declare-datatypes (A1!174 R!188) ((fun1!186 (fun1!187 (f!409 (=> A1!174 R!188)) (pre!243 (=> A1!174 Bool))))))

(assert (not (=> (> x!72 0) (let ((i!18 (fun1!187 (lambda ((a!22 Int)) (+ a!22 1)) (lambda ((a!135 Int)) true)))) (@ (f!409 (fun1!187 (pre!243 i!18) (lambda ((x!627 Int)) true))) 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!225) ((array!110 (array!111 (arr!56 (Array (_ BitVec 32) A!225)) (size!90 (_ BitVec 32))))))

(declare-const a!23 (array!110 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!110 A!224) (bvsge (size!90 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!90 a!23) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!90 a!23))) (select (arr!56 a!23) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)) (let ((x$1!76 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!90 a!23))) (select (arr!56 a!23) #b00000000000000000000000000000010)))) (= x$1!76 #b00000000000000000000000000000101)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!225) ((array!114 (array!115 (arr!58 (Array (_ BitVec 32) A!225)) (size!94 (_ BitVec 32))))))

(declare-const a!23 (array!114 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!114 A!224) (bvsge (size!94 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!94 a!23) #b00000000000000000000000000000010) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!94 a!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!225) ((array!118 (array!119 (arr!60 (Array (_ BitVec 32) A!225)) (size!96 (_ BitVec 32))))))

(declare-const a!23 (array!118 (_ BitVec 32)))

(datatype-invariant (par (A!224) array!97 (array!118 A!224) (bvsge (size!96 array!97) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsgt (size!96 a!23) #b00000000000000000000000000000010) (= (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!96 a!23))) (select (arr!60 a!23) #b00000000000000000000000000000010)) #b00000000000000000000000000000101)) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!96 a!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!239) ((array!126 (array!127 (arr!64 (Array (_ BitVec 32) A!239)) (size!100 (_ BitVec 32))))))

(datatype-invariant (par (A!238) array!123 (array!126 A!238) (bvsge (size!100 array!123) #b00000000000000000000000000000000)))

(assert (not (let ((b!351 (array!127 (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001) #b00000000000000000000000000000001 #b00000000000000000000000000000010) #b00000000000000000000000000000010 #b00000000000000000000000000000011) #b00000000000000000000000000000011))) (let ((a!139 (array!127 (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001) #b00000000000000000000000000000001 #b00000000000000000000000000000010) #b00000000000000000000000000000010 #b00000000000000000000000000000011) #b00000000000000000000000000000011))) (let ((x$1!78 (size!100 a!139))) (bvsgt x$1!78 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!241) ((array!128 (array!129 (arr!65 (Array (_ BitVec 32) A!241)) (size!101 (_ BitVec 32))))))

(datatype-invariant (par (A!240) array!125 (array!128 A!240) (bvsge (size!101 array!125) #b00000000000000000000000000000000)))

(assert (not (let ((x!74 #b00000000000000000000000000001010)) (let ((a!138 (array!129 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!74) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (let ((x$1!79 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!101 a!138))) (select (arr!65 a!138) #b00000000000000000000000000000010)))) (bvsge x$1!79 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!241) ((array!136 (array!137 (arr!69 (Array (_ BitVec 32) A!241)) (size!105 (_ BitVec 32))))))

(datatype-invariant (par (A!240) array!125 (array!136 A!240) (bvsge (size!105 array!125) #b00000000000000000000000000000000)))

(assert (not (let ((x!74 #b00000000000000000000000000001010)) (let ((a!138 (array!137 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!74) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!105 a!138)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!73 (_ BitVec 32))

(declare-datatypes (A!247) ((array!144 (array!145 (arr!73 (Array (_ BitVec 32) A!247)) (size!111 (_ BitVec 32))))))

(datatype-invariant (par (A!246) array!133 (array!144 A!246) (bvsge (size!111 array!133) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge x!73 #b00000000000000000000000000000000) (let ((a!141 (array!145 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!73) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (let ((x$1!80 (assume (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!111 a!141))) (select (arr!73 a!141) #b00000000000000000000000000000010)))) (bvsge x$1!80 #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!20 (_ BitVec 32))

(assert (not (=> (bvsgt i!20 #b00000000000000000000000000000000) (bvsgt i!20 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!38 (Cons!79 (head!126 (_ BitVec 32)) (tail!132 List!38)) (Nil!79))))

(declare-datatypes () ((AbsQueue!1 (Queue!1 (front!8 List!38) (rear!7 List!38)))))

(define-fun-rec size!2 ((list!0 List!38)) Int (let ((x$1!6 (ite (is-Nil!79 list!0) 0 (+ 1 (size!2 (tail!132 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!38)) (Set (_ BitVec 32)) (ite (is-Nil!79 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!126 l!21)) (content!4 (tail!132 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!38) (l2!10 List!38)) List!38 (let ((res!35 (ite (is-Nil!79 l1!12) l2!10 (Cons!79 (head!126 l1!12) (concat!0 (tail!132 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!38)) List!38 (let ((x$2!4 (ite (is-Nil!79 l!22) Nil!79 (concat!0 (reverse!1 (tail!132 l!22)) (Cons!79 (head!126 l!22) Nil!79))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!1)) List!38 (concat!0 (front!8 queue!0) (reverse!1 (rear!7 queue!0))))

(declare-const queue!6 AbsQueue!1)

(declare-const list!1 List!38)

(define-fun isEmpty!2 ((queue!2 AbsQueue!1)) Bool (ite (and (is-Queue!1 queue!2) (is-Nil!79 (front!8 queue!2)) (is-Nil!79 (rear!7 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!1)) Bool (>= (size!2 (front!8 queue!1)) (size!2 (rear!7 queue!1))))

(assert (not (=> (and (= (asList!0 queue!6) list!1) (is-Cons!79 list!1)) (let ((x!71 (head!126 list!1))) (=> (and (is-Queue!1 queue!6) (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6)) (and (isAmortized!0 queue!6) (not (isEmpty!2 queue!6))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!150 (array!151 (arr!76 (Array (_ BitVec 32) A!259)) (size!115 (_ BitVec 32))))))

(declare-const a!30 (array!150 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!150 A!258) (bvsge (size!115 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!115 a!30) #b00000000000000000000000000000000) (let ((a2!8 (array!151 (store (arr!76 a!30) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!115 a!30))) #b00000000000000000000000000000000) #b00000000000000000000000000000010) (size!115 a!30)))) (let ((res!293 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!115 a2!8))) (select (arr!76 a2!8) #b00000000000000000000000000000000)))) (= res!293 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const a!32 Int)

(assert (not (=> (> a!32 0) (> 1 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!40 (Cons!81 (head!128 (_ BitVec 32)) (tail!134 List!40)) (Nil!81))))

(declare-datatypes () ((AbsQueue!3 (Queue!3 (front!10 List!40) (rear!9 List!40)))))

(declare-const queue!6 AbsQueue!3)

(define-fun isEmpty!2 ((queue!2 AbsQueue!3)) Bool (ite (and (is-Queue!3 queue!2) (is-Nil!81 (front!10 queue!2)) (is-Nil!81 (rear!9 queue!2))) true false))

(define-fun-rec size!2 ((list!0 List!40)) Int (let ((x$1!6 (ite (is-Nil!81 list!0) 0 (+ 1 (size!2 (tail!134 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!3)) Bool (>= (size!2 (front!10 queue!1)) (size!2 (rear!9 queue!1))))

(define-fun-rec content!4 ((l!21 List!40)) (Set (_ BitVec 32)) (ite (is-Nil!81 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!128 l!21)) (content!4 (tail!134 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!40) (l2!10 List!40)) List!40 (let ((res!35 (ite (is-Nil!81 l1!12) l2!10 (Cons!81 (head!128 l1!12) (concat!0 (tail!134 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!40)) List!40 (let ((x$2!4 (ite (is-Nil!81 l!22) Nil!81 (concat!0 (reverse!1 (tail!134 l!22)) (Cons!81 (head!128 l!22) Nil!81))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!3)) List!40 (concat!0 (front!10 queue!0) (reverse!1 (rear!9 queue!0))))

(declare-const list!1 List!40)

(define-fun front!5 ((queue!5 AbsQueue!3)) (_ BitVec 32) (head!128 (front!10 queue!5)))

(assert (not (=> (and (is-Queue!3 queue!6) (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6)) (ite (= (asList!0 queue!6) list!1) (= (front!5 queue!6) (head!128 list!1)) true))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!73 (_ BitVec 32))

(declare-datatypes (A!247) ((array!156 (array!157 (arr!79 (Array (_ BitVec 32) A!247)) (size!118 (_ BitVec 32))))))

(datatype-invariant (par (A!246) array!133 (array!156 A!246) (bvsge (size!118 array!133) #b00000000000000000000000000000000)))

(assert (not (=> (bvsge x!73 #b00000000000000000000000000000000) (let ((a!141 (array!157 (store (store (store (store (store ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000000) #b00000000000000000000000000000001 #b00000000000000000000000000000000) #b00000000000000000000000000000010 x!73) #b00000000000000000000000000000011 #b00000000000000000000000000000000) #b00000000000000000000000000000100 #b00000000000000000000000000000000) #b00000000000000000000000000000101))) (and (bvsge #b00000000000000000000000000000010 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000010 (size!118 a!141)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!20 (_ BitVec 32))

(declare-datatypes (A!251) ((array!160 (array!161 (arr!81 (Array (_ BitVec 32) A!251)) (size!120 (_ BitVec 32))))))

(define-fun foo!3 ((i!19 (_ BitVec 32))) (array!160 (_ BitVec 32)) (assume (bvsgt i!19 #b00000000000000000000000000000000) (let ((res!38 (array!161 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) i!19))) (assume (= (size!120 res!38) i!19) res!38))))

(datatype-invariant (par (A!250) array!141 (array!160 A!250) (bvsge (size!120 array!141) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt i!20 #b00000000000000000000000000000000) (let ((b!352 (foo!3 i!20))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!120 b!352)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const a!32 Int)

(define-fun bar!2 ((a!33 Int)) Int (assume (> a!33 0) (let ((x$4!2 (assume (> a!33 0) (+ a!33 2)))) (assume (> x$4!2 a!33) x$4!2))))

(assert (not (=> (> a!32 0) (let ((x$2!37 (assume (> a!32 0) (+ a!32 (bar!2 1))))) (> x$2!37 a!32)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!164 (array!165 (arr!83 (Array (_ BitVec 32) A!259)) (size!122 (_ BitVec 32))))))

(declare-const a!30 (array!164 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!164 A!258) (bvsge (size!122 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!122 a!30) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!122 a!30))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!42 (Cons!83 (head!130 (_ BitVec 32)) (tail!136 List!42)) (Nil!83))))

(declare-datatypes () ((AbsQueue!5 (Queue!5 (front!12 List!42) (rear!11 List!42)))))

(define-fun-rec size!2 ((list!0 List!42)) Int (let ((x$1!6 (ite (is-Nil!83 list!0) 0 (+ 1 (size!2 (tail!136 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!5)) Bool (>= (size!2 (front!12 queue!1)) (size!2 (rear!11 queue!1))))

(declare-const queue!5 AbsQueue!5)

(define-fun isEmpty!2 ((queue!2 AbsQueue!5)) Bool (ite (and (is-Queue!5 queue!2) (is-Nil!83 (front!12 queue!2)) (is-Nil!83 (rear!11 queue!2))) true false))

(assert (not (=> (and (isAmortized!0 queue!5) (not (isEmpty!2 queue!5))) (and (is-Queue!5 queue!5) (is-Cons!83 (front!12 queue!5))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!19 (_ BitVec 32))

(declare-datatypes (A!251) ((array!168 (array!169 (arr!85 (Array (_ BitVec 32) A!251)) (size!124 (_ BitVec 32))))))

(datatype-invariant (par (A!250) array!141 (array!168 A!250) (bvsge (size!124 array!141) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt i!19 #b00000000000000000000000000000000) (let ((res!286 (array!169 ((as const (Array (_ BitVec 32) (_ BitVec 32))) #b00000000000000000000000000000000) i!19))) (= (size!124 res!286) i!19)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!170 (array!171 (arr!86 (Array (_ BitVec 32) A!259)) (size!125 (_ BitVec 32))))))

(declare-const a!30 (array!170 (_ BitVec 32)))

(datatype-invariant (par (A!258) array!149 (array!170 A!258) (bvsge (size!125 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!125 a!30) #b00000000000000000000000000000000) (let ((a2!8 (array!171 (store (arr!86 a!30) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!125 a!30))) #b00000000000000000000000000000000) #b00000000000000000000000000000010) (size!125 a!30)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!125 a2!8)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const a!32 Int)

(assert (not (=> (> a!32 0) (> a!32 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!176 (array!177 (arr!89 (Array (_ BitVec 32) A!259)) (size!128 (_ BitVec 32))))))

(declare-const a!31 (array!176 Int))

(datatype-invariant (par (A!258) array!149 (array!176 A!258) (bvsge (size!128 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!128 a!31) #b00000000000000000000000000000000) (let ((a2!9 (array!177 (store (arr!89 a!31) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!128 a!31))) #b00000000000000000000000000000000) 2) (size!128 a!31)))) (let ((res!294 (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!128 a2!9))) (select (arr!89 a2!9) #b00000000000000000000000000000000)))) (= res!294 2))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!180 (array!181 (arr!91 (Array (_ BitVec 32) A!259)) (size!130 (_ BitVec 32))))))

(declare-const a!31 (array!180 Int))

(datatype-invariant (par (A!258) array!149 (array!180 A!258) (bvsge (size!130 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!130 a!31) #b00000000000000000000000000000000) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!130 a!31))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const a!33 Int)

(assert (not (=> (> a!33 0) (let ((x$4!12 (assume (> a!33 0) (+ a!33 2)))) (> x$4!12 a!33)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A!259) ((array!186 (array!187 (arr!94 (Array (_ BitVec 32) A!259)) (size!133 (_ BitVec 32))))))

(declare-const a!31 (array!186 Int))

(datatype-invariant (par (A!258) array!149 (array!186 A!258) (bvsge (size!133 array!149) #b00000000000000000000000000000000)))

(assert (not (=> (bvsgt (size!133 a!31) #b00000000000000000000000000000000) (let ((a2!9 (array!187 (store (arr!94 a!31) (assume (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!133 a!31))) #b00000000000000000000000000000000) 2) (size!133 a!31)))) (and (bvsge #b00000000000000000000000000000000 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000000 (size!133 a2!9)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!22 (fun2!23 (f!499 (=> A1!271 A2!189 R!294)) (pre!333 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!22 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!22 B!30 B!30 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!499 (fun2!23 (pre!333 (as f1!0 (fun2!22 A!41 A!41 A!41))) (lambda ((x!678 A!41) (x!679 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!499 (fun2!23 (pre!333 (as f2!1 (fun2!22 B!30 B!30 B!30))) (lambda ((x!680 B!30) (x!681 B!30)) true))) x!653 x!654))) (forall ((x!649 A!41)(x!650 A!41)) (@ (f!499 (fun2!23 (pre!333 (as f1!0 (fun2!22 A!41 A!41 A!41))) (lambda ((x!682 A!41) (x!683 A!41)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const a!33 Int)

(assert (not (=> (> a!33 0) (> a!33 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!44 (Cons!85 (head!132 (_ BitVec 32)) (tail!138 List!44)) (Nil!85))))

(declare-datatypes () ((AbsQueue!7 (Queue!7 (front!14 List!44) (rear!13 List!44)))))

(define-fun-rec size!2 ((list!0 List!44)) Int (let ((x$1!6 (ite (is-Nil!85 list!0) 0 (+ 1 (size!2 (tail!138 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!7)) Bool (>= (size!2 (front!14 queue!1)) (size!2 (rear!13 queue!1))))

(declare-const queue!4 AbsQueue!7)

(define-fun isEmpty!2 ((queue!2 AbsQueue!7)) Bool (ite (and (is-Queue!7 queue!2) (is-Nil!85 (front!14 queue!2)) (is-Nil!85 (rear!13 queue!2))) true false))

(define-fun-rec content!4 ((l!21 List!44)) (Set (_ BitVec 32)) (ite (is-Nil!85 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!132 l!21)) (content!4 (tail!138 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!44) (l2!10 List!44)) List!44 (let ((res!35 (ite (is-Nil!85 l1!12) l2!10 (Cons!85 (head!132 l1!12) (concat!0 (tail!138 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!44)) List!44 (let ((x$2!4 (ite (is-Nil!85 l!22) Nil!85 (concat!0 (reverse!1 (tail!138 l!22)) (Cons!85 (head!132 l!22) Nil!85))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun amortizedQueue!0 ((front!3 List!44) (rear!3 List!44)) AbsQueue!7 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!7 front!3 rear!3) (Queue!7 (concat!0 front!3 (reverse!1 rear!3)) Nil!85)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(assert (not (=> (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!4 (amortizedQueue!0 (tail!138 (front!14 queue!4)) (rear!13 queue!4)))) (isAmortized!0 x$5!4)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!81 Real)

(assert (not (= (assume (not (= (/ 2 1) (/ 0 1))) (/ x!81 (/ 2 1))) (* x!81 (/ 1 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!46 (Cons!87 (head!134 (_ BitVec 32)) (tail!140 List!46)) (Nil!87))))

(declare-const l!22 List!46)

(define-fun-rec size!2 ((list!0 List!46)) Int (let ((x$1!6 (ite (is-Nil!87 list!0) 0 (+ 1 (size!2 (tail!140 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!46)) (Set (_ BitVec 32)) (ite (is-Nil!87 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!134 l!21)) (content!4 (tail!140 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!46) (l2!10 List!46)) List!46 (let ((res!35 (ite (is-Nil!87 l1!12) l2!10 (Cons!87 (head!134 l1!12) (concat!0 (tail!140 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!46)) List!46 (let ((x$2!4 (ite (is-Nil!87 l!22) Nil!87 (concat!0 (reverse!1 (tail!140 l!22)) (Cons!87 (head!134 l!22) Nil!87))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(assert (not (let ((x$2!36 (ite (is-Nil!87 l!22) Nil!87 (concat!0 (reverse!1 (tail!140 l!22)) (Cons!87 (head!134 l!22) Nil!87))))) (= (content!4 x$2!36) (content!4 l!22)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!47 (Cons!89 (head!136 (_ BitVec 32)) (tail!142 List!47)) (Nil!89))))

(declare-datatypes () ((AbsQueue!9 (Queue!9 (front!16 List!47) (rear!15 List!47)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!9)) Bool (ite (and (is-Queue!9 queue!2) (is-Nil!89 (front!16 queue!2)) (is-Nil!89 (rear!15 queue!2))) true false))

(declare-const front!6 List!47)

(declare-const rear!6 List!47)

(define-fun-rec size!2 ((list!0 List!47)) Int (let ((x$1!6 (ite (is-Nil!89 list!0) 0 (+ 1 (size!2 (tail!142 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!9)) Bool (>= (size!2 (front!16 queue!1)) (size!2 (rear!15 queue!1))))

(define-fun-rec content!4 ((l!21 List!47)) (Set (_ BitVec 32)) (ite (is-Nil!89 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!136 l!21)) (content!4 (tail!142 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!47) (l2!10 List!47)) List!47 (let ((res!35 (ite (is-Nil!89 l1!12) l2!10 (Cons!89 (head!136 l1!12) (concat!0 (tail!142 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!47)) List!47 (let ((x$2!4 (ite (is-Nil!89 l!22) Nil!89 (concat!0 (reverse!1 (tail!142 l!22)) (Cons!89 (head!136 l!22) Nil!89))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!9)) List!47 (concat!0 (front!16 queue!0) (reverse!1 (rear!15 queue!0))))

(declare-const list!2 List!47)

(assert (not (=> (and (not (isEmpty!2 (Queue!9 front!6 rear!6))) (isAmortized!0 (Queue!9 front!6 rear!6)) (= (asList!0 (Queue!9 front!6 rear!6)) list!2)) (is-Cons!89 list!2))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!29 (fun2!30 (f!513 (=> A1!271 A2!189 R!294)) (pre!347 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!29 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!29 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!29 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!513 f!31) (@ (f!513 f!31) x!76 y!8) z!9) (@ (f!513 f!31) x!76 (@ (f!513 f!31) y!8 z!9)))))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!513 (fun2!30 (pre!347 (as f1!0 (fun2!29 A!41 A!41 A!41))) (lambda ((x!714 A!41) (x!715 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!513 (fun2!30 (pre!347 (as f2!1 (fun2!29 B!30 B!30 B!30))) (lambda ((x!716 B!30) (x!717 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!29 A!41 A!41 A!41)))) (forall ((x!649 B!30)(x!650 B!30)) (@ (f!513 (fun2!30 (pre!347 (as f2!1 (fun2!29 B!30 B!30 B!30))) (lambda ((x!718 B!30) (x!719 B!30)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= (/ 2 1) (/ 0 1)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!50 (Cons!92 (head!139 (_ BitVec 32)) (tail!145 List!50)) (Nil!92))))

(declare-datatypes () ((AbsQueue!11 (Queue!11 (front!18 List!50) (rear!17 List!50)))))

(define-fun-rec size!2 ((list!0 List!50)) Int (let ((x$1!6 (ite (is-Nil!92 list!0) 0 (+ 1 (size!2 (tail!145 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!11)) Bool (>= (size!2 (front!18 queue!1)) (size!2 (rear!17 queue!1))))

(declare-const queue!4 AbsQueue!11)

(define-fun isEmpty!2 ((queue!2 AbsQueue!11)) Bool (ite (and (is-Queue!11 queue!2) (is-Nil!92 (front!18 queue!2)) (is-Nil!92 (rear!17 queue!2))) true false))

(assert (not (=> (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (and (is-Queue!11 queue!4) (is-Cons!92 (front!18 queue!4))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!52 (Cons!94 (head!141 (_ BitVec 32)) (tail!147 List!52)) (Nil!94))))

(declare-datatypes () ((AbsQueue!13 (Queue!13 (front!20 List!52) (rear!19 List!52)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!13)) Bool (ite (and (is-Queue!13 queue!2) (is-Nil!94 (front!20 queue!2)) (is-Nil!94 (rear!19 queue!2))) true false))

(declare-const queue!6 AbsQueue!13)

(define-fun-rec size!2 ((list!0 List!52)) Int (let ((x$1!6 (ite (is-Nil!94 list!0) 0 (+ 1 (size!2 (tail!147 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!13)) Bool (>= (size!2 (front!20 queue!1)) (size!2 (rear!19 queue!1))))

(define-fun-rec content!4 ((l!21 List!52)) (Set (_ BitVec 32)) (ite (is-Nil!94 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!141 l!21)) (content!4 (tail!147 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!52) (l2!10 List!52)) List!52 (let ((res!35 (ite (is-Nil!94 l1!12) l2!10 (Cons!94 (head!141 l1!12) (concat!0 (tail!147 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!52)) List!52 (let ((x$2!4 (ite (is-Nil!94 l!22) Nil!94 (concat!0 (reverse!1 (tail!147 l!22)) (Cons!94 (head!141 l!22) Nil!94))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!13)) List!52 (concat!0 (front!20 queue!0) (reverse!1 (rear!19 queue!0))))

(declare-const list!1 List!52)

(assert (not (=> (and (not (isEmpty!2 queue!6)) (isAmortized!0 queue!6) (= (asList!0 queue!6) list!1)) (is-Cons!94 list!1))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!80 Real)

(declare-const y!12 Real)

(assert (not (let ((res!311 (ite (>= x!80 y!12) x!80 y!12))) (and (and (or (= res!311 x!80) (= res!311 y!12)) (>= res!311 x!80)) (>= res!311 y!12)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!79 Real)

(declare-const y!11 Real)

(assert (not (=> (and (>= x!79 (/ 0 1)) (>= y!11 (/ 0 1))) (let ((x$1!81 (+ x!79 y!11))) (>= x$1!81 (/ 0 1))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!35 (fun2!36 (f!517 (=> A1!271 A2!189 R!294)) (pre!350 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!35 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!35 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!35 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!517 f!31) (@ (f!517 f!31) x!76 y!8) z!9) (@ (f!517 f!31) x!76 (@ (f!517 f!31) y!8 z!9)))))))

(declare-datatypes (A0!0 A1!306) ((tuple2!0 (tuple2!1 (_1!0 A0!0) (_2!0 A1!306)))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!517 (fun2!36 (pre!350 (as f1!0 (fun2!35 A!41 A!41 A!41))) (lambda ((x!753 A!41) (x!754 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!517 (fun2!36 (pre!350 (as f2!1 (fun2!35 B!30 B!30 B!30))) (lambda ((x!755 B!30) (x!756 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!35 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!35 B!30 B!30 B!30)))) (let ((fp!0 (fun2!36 (lambda ((p1!0 (tuple2!0 A!41 B!30)) (p2!0 (tuple2!0 A!41 B!30))) (tuple2!1 (@ (f!517 (as f1!0 (fun2!35 A!41 A!41 A!41))) (_1!0 p1!0) (_1!0 p2!0)) (@ (f!517 (as f2!1 (fun2!35 B!30 B!30 B!30))) (_2!0 p1!0) (_2!0 p2!0)))) (lambda ((p1!7 (tuple2!0 A!41 B!30)) (p2!9 (tuple2!0 A!41 B!30))) (and (@ (f!517 (fun2!36 (pre!350 (as f1!0 (fun2!35 A!41 A!41 A!41))) (lambda ((x!757 A!41) (x!758 A!41)) true))) (_1!0 p1!7) (_1!0 p2!9)) (@ (f!517 (fun2!36 (pre!350 (as f2!1 (fun2!35 B!30 B!30 B!30))) (lambda ((x!759 B!30) (x!760 B!30)) true))) (_2!0 p1!7) (_2!0 p2!9))))))) (forall ((x!649 (tuple2!0 A!41 B!30))(x!650 (tuple2!0 A!41 B!30))) (@ (f!517 (fun2!36 (pre!350 fp!0) (lambda ((x!761 (tuple2!0 A!41 B!30)) (x!762 (tuple2!0 A!41 B!30))) true))) x!649 x!650)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!82 Real)

(assert (not (=> (> x!82 (/ 0 1)) (let ((res!312 (* (/ 2 1) x!82))) (> res!312 x!82)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!54 (Cons!96 (head!143 (_ BitVec 32)) (tail!149 List!54)) (Nil!96))))

(declare-datatypes () ((AbsQueue!15 (Queue!15 (front!22 List!54) (rear!21 List!54)))))

(declare-const queue!2 AbsQueue!15)

(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!1 (KeyValuePair!1 (key!9 (_ BitVec 32)) (value!39 (_ BitVec 32))))))

(declare-datatypes () ((List!56 (Cons!98 (head!145 KeyValuePairAbs!1) (tail!151 List!56)) (Nil!98))))

(declare-const l2!11 List!56)

(declare-const l1!13 List!56)

(define-fun-rec domain!0 ((l!23 List!56)) (Set (_ BitVec 32)) (ite (is-Nil!98 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!9 (head!145 l!23))) (domain!0 (tail!151 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!56) (e!6 KeyValuePairAbs!1)) List!56 (let ((res!41 (ite (is-Nil!98 l!26) (Cons!98 e!6 Nil!98) (ite (= (key!9 e!6) (key!9 (head!145 l!26))) (Cons!98 (KeyValuePair!1 (key!9 e!6) (value!39 e!6)) (tail!151 l!26)) (Cons!98 (KeyValuePair!1 (key!9 (head!145 l!26)) (value!39 (head!145 l!26))) (updateElem!0 (tail!151 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!9 e!6)))) res!41)))

(define-fun-rec updateAll!0 ((l1!13 List!56) (l2!11 List!56)) List!56 (let ((x$1!12 (ite (is-Nil!98 l2!11) l1!13 (updateAll!0 (updateElem!0 l1!13 (head!145 l2!11)) (tail!151 l2!11))))) (assume (= (domain!0 x$1!12) (union (domain!0 l1!13) (domain!0 l2!11))) x$1!12)))

(assert (not (let ((x$1!82 (ite (is-Nil!98 l2!11) l1!13 (updateAll!0 (updateElem!0 l1!13 (head!145 l2!11)) (tail!151 l2!11))))) (= (domain!0 x$1!82) (union (domain!0 l1!13) (domain!0 l2!11))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!2 (KeyValuePair!2 (key!10 (_ BitVec 32)) (value!40 (_ BitVec 32))))))

(declare-datatypes () ((List!57 (Cons!99 (head!146 KeyValuePairAbs!2) (tail!152 List!57)) (Nil!99))))

(declare-const l!26 List!57)

(declare-const e!6 KeyValuePairAbs!2)

(define-fun-rec domain!0 ((l!23 List!57)) (Set (_ BitVec 32)) (ite (is-Nil!99 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!10 (head!146 l!23))) (domain!0 (tail!152 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!57) (e!6 KeyValuePairAbs!2)) List!57 (let ((res!41 (ite (is-Nil!99 l!26) (Cons!99 e!6 Nil!99) (ite (= (key!10 e!6) (key!10 (head!146 l!26))) (Cons!99 (KeyValuePair!2 (key!10 e!6) (value!40 e!6)) (tail!152 l!26)) (Cons!99 (KeyValuePair!2 (key!10 (head!146 l!26)) (value!40 (head!146 l!26))) (updateElem!0 (tail!152 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!10 e!6)))) res!41)))

(assert (not (let ((res!328 (ite (is-Nil!99 l!26) (Cons!99 e!6 Nil!99) (ite (= (key!10 e!6) (key!10 (head!146 l!26))) (Cons!99 (KeyValuePair!2 (key!10 e!6) (value!40 e!6)) (tail!152 l!26)) (Cons!99 (KeyValuePair!2 (key!10 (head!146 l!26)) (value!40 (head!146 l!26))) (updateElem!0 (tail!152 l!26) e!6)))))) (= (domain!0 res!328) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!10 e!6)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!58 (Cons!100 (head!147 (_ BitVec 32)) (tail!153 List!58)) (Nil!100))))

(declare-datatypes () ((AbsQueue!17 (Queue!17 (front!24 List!58) (rear!23 List!58)))))

(define-fun-rec size!2 ((list!0 List!58)) Int (let ((x$1!6 (ite (is-Nil!100 list!0) 0 (+ 1 (size!2 (tail!153 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!58)) (Set (_ BitVec 32)) (ite (is-Nil!100 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!147 l!21)) (content!4 (tail!153 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!58) (l2!10 List!58)) List!58 (let ((res!35 (ite (is-Nil!100 l1!12) l2!10 (Cons!100 (head!147 l1!12) (concat!0 (tail!153 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!58)) List!58 (let ((x$2!4 (ite (is-Nil!100 l!22) Nil!100 (concat!0 (reverse!1 (tail!153 l!22)) (Cons!100 (head!147 l!22) Nil!100))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!17)) Bool (>= (size!2 (front!24 queue!1)) (size!2 (rear!23 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!58) (rear!3 List!58)) AbsQueue!17 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!17 front!3 rear!3) (Queue!17 (concat!0 front!3 (reverse!1 rear!3)) Nil!100)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(declare-const queue!3 AbsQueue!17)

(declare-const elem!1 (_ BitVec 32))

(assert (not (let ((x$4!11 (amortizedQueue!0 (front!24 queue!3) (Cons!100 elem!1 (rear!23 queue!3))))) (isAmortized!0 x$4!11))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A0!3 A1!319) ((tuple2!2 (tuple2!3 (_1!1 A0!3) (_2!1 A1!319)))))

(declare-datatypes () ((Num!1 (Succ!2 (pred!1 Num!1)) (Zero!2))))

(declare-datatypes () ((Wrapper!1 (Wrapper!2 (num!3 Num!1)))))

(define-fun zipWrap!0 ((w1!0 Wrapper!1) (w2!0 Wrapper!1)) (tuple2!2 Wrapper!1 Wrapper!1) (tuple2!3 w1!0 w2!0))

(define-fun boolToNum!0 ((b!21 Bool)) Num!1 (ite b!21 Zero!2 (Succ!2 Zero!2)))

(declare-const b!22 Bool)

(assert (not (let ((x$1!14 (tuple2!3 (_1!1 (zipWrap!0 (Wrapper!2 (boolToNum!0 b!22)) (Wrapper!2 (boolToNum!0 (not b!22))))) (_2!1 (zipWrap!0 (Wrapper!2 (boolToNum!0 b!22)) (Wrapper!2 (boolToNum!0 (not b!22)))))))) (let ((z2!0 (_2!1 x$1!14))) (or (= (num!3 (_1!1 x$1!14)) Zero!2) (= (num!3 z2!0) Zero!2))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!62 (Cons!104 (head!151 (_ BitVec 32)) (tail!157 List!62)) (Nil!104))))

(declare-datatypes () ((AbsQueue!19 (Queue!19 (front!26 List!62) (rear!25 List!62)))))

(declare-const queue!0 AbsQueue!19)

(assert (not (is-Queue!19 queue!0)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!63 (Cons!105 (head!152 (_ BitVec 32)) (tail!158 List!63)) (Nil!105))))

(declare-datatypes () ((AbsQueue!20 (Queue!20 (front!27 List!63) (rear!26 List!63)))))

(declare-const queue!3 AbsQueue!20)

(assert (not (is-Queue!20 queue!3)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!66 (Cons!108 (head!155 (_ BitVec 32)) (tail!161 List!66)) (Nil!108))))

(declare-datatypes () ((AbsQueue!23 (Queue!23 (front!30 List!66) (rear!29 List!66)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!23)) Bool (ite (and (is-Queue!23 queue!2) (is-Nil!108 (front!30 queue!2)) (is-Nil!108 (rear!29 queue!2))) true false))

(declare-const queue!8 AbsQueue!23)

(define-fun-rec size!2 ((list!0 List!66)) Int (let ((x$1!6 (ite (is-Nil!108 list!0) 0 (+ 1 (size!2 (tail!161 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!66)) (Set (_ BitVec 32)) (ite (is-Nil!108 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!155 l!21)) (content!4 (tail!161 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!66) (l2!10 List!66)) List!66 (let ((res!35 (ite (is-Nil!108 l1!12) l2!10 (Cons!108 (head!155 l1!12) (concat!0 (tail!161 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!66)) List!66 (let ((x$2!4 (ite (is-Nil!108 l!22) Nil!108 (concat!0 (reverse!1 (tail!161 l!22)) (Cons!108 (head!155 l!22) Nil!108))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!23)) Bool (>= (size!2 (front!30 queue!1)) (size!2 (rear!29 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!66) (rear!3 List!66)) AbsQueue!23 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!23 front!3 rear!3) (Queue!23 (concat!0 front!3 (reverse!1 rear!3)) Nil!108)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!23) (elem!1 (_ BitVec 32))) AbsQueue!23 (let ((x$4!1 (amortizedQueue!0 (front!30 queue!3) (Cons!108 elem!1 (rear!29 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (and (isAmortized!0 q3!0) (not (isEmpty!2 q3!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!68 (Cons!110 (head!157 (_ BitVec 32)) (tail!163 List!68)) (Nil!110))))

(define-fun-rec size!2 ((list!0 List!68)) Int (let ((x$1!6 (ite (is-Nil!110 list!0) 0 (+ 1 (size!2 (tail!163 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(declare-const rear!3 List!68)

(declare-const front!3 List!68)

(declare-datatypes () ((AbsQueue!25 (Queue!25 (front!32 List!68) (rear!31 List!68)))))

(define-fun-rec content!4 ((l!21 List!68)) (Set (_ BitVec 32)) (ite (is-Nil!110 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!157 l!21)) (content!4 (tail!163 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!68) (l2!10 List!68)) List!68 (let ((res!35 (ite (is-Nil!110 l1!12) l2!10 (Cons!110 (head!157 l1!12) (concat!0 (tail!163 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!68)) List!68 (let ((x$2!4 (ite (is-Nil!110 l!22) Nil!110 (concat!0 (reverse!1 (tail!163 l!22)) (Cons!110 (head!157 l!22) Nil!110))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!25)) Bool (>= (size!2 (front!32 queue!1)) (size!2 (rear!31 queue!1))))

(assert (not (let ((x$3!16 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!25 front!3 rear!3) (Queue!25 (concat!0 front!3 (reverse!1 rear!3)) Nil!110)))) (isAmortized!0 x$3!16))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!43 (fun2!44 (f!545 (=> A1!271 A2!189 R!294)) (pre!376 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!43 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!43 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!43 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!545 f!31) (@ (f!545 f!31) x!76 y!8) z!9) (@ (f!545 f!31) x!76 (@ (f!545 f!31) y!8 z!9)))))))

(declare-datatypes (A0!6 A1!324) ((tuple2!8 (tuple2!9 (_1!4 A0!6) (_2!4 A1!324)))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!545 (fun2!44 (pre!376 (as f1!0 (fun2!43 A!41 A!41 A!41))) (lambda ((x!818 A!41) (x!819 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!545 (fun2!44 (pre!376 (as f2!1 (fun2!43 B!30 B!30 B!30))) (lambda ((x!820 B!30) (x!821 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!43 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!43 B!30 B!30 B!30)))) (let ((fp!0 (fun2!44 (lambda ((p1!0 (tuple2!8 A!41 B!30)) (p2!0 (tuple2!8 A!41 B!30))) (tuple2!9 (@ (f!545 (as f1!0 (fun2!43 A!41 A!41 A!41))) (_1!4 p1!0) (_1!4 p2!0)) (@ (f!545 (as f2!1 (fun2!43 B!30 B!30 B!30))) (_2!4 p1!0) (_2!4 p2!0)))) (lambda ((p1!9 (tuple2!8 A!41 B!30)) (p2!11 (tuple2!8 A!41 B!30))) (and (@ (f!545 (fun2!44 (pre!376 (as f1!0 (fun2!43 A!41 A!41 A!41))) (lambda ((x!822 A!41) (x!823 A!41)) true))) (_1!4 p1!9) (_1!4 p2!11)) (@ (f!545 (fun2!44 (pre!376 (as f2!1 (fun2!43 B!30 B!30 B!30))) (lambda ((x!824 B!30) (x!825 B!30)) true))) (_2!4 p1!9) (_2!4 p2!11))))))) (isAssociative!0 fp!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!70 (Cons!112 (head!159 (_ BitVec 32)) (tail!165 List!70)) (Nil!112))))

(declare-datatypes () ((AbsQueue!27 (Queue!27 (front!34 List!70) (rear!33 List!70)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!27)) Bool (ite (and (is-Queue!27 queue!2) (is-Nil!112 (front!34 queue!2)) (is-Nil!112 (rear!33 queue!2))) true false))

(declare-const queue!7 AbsQueue!27)

(define-fun-rec size!2 ((list!0 List!70)) Int (let ((x$1!6 (ite (is-Nil!112 list!0) 0 (+ 1 (size!2 (tail!165 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!27)) Bool (>= (size!2 (front!34 queue!1)) (size!2 (rear!33 queue!1))))

(define-fun-rec content!4 ((l!21 List!70)) (Set (_ BitVec 32)) (ite (is-Nil!112 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!159 l!21)) (content!4 (tail!165 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!70) (l2!10 List!70)) List!70 (let ((res!35 (ite (is-Nil!112 l1!12) l2!10 (Cons!112 (head!159 l1!12) (concat!0 (tail!165 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!70)) List!70 (let ((x$2!4 (ite (is-Nil!112 l!22) Nil!112 (concat!0 (reverse!1 (tail!165 l!22)) (Cons!112 (head!159 l!22) Nil!112))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun amortizedQueue!0 ((front!3 List!70) (rear!3 List!70)) AbsQueue!27 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!27 front!3 rear!3) (Queue!27 (concat!0 front!3 (reverse!1 rear!3)) Nil!112)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!27) (elem!1 (_ BitVec 32))) AbsQueue!27 (let ((x$4!1 (amortizedQueue!0 (front!34 queue!3) (Cons!112 elem!1 (rear!33 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const elem!4 (_ BitVec 32))

(assert (not (=> (isEmpty!2 queue!7) (and (isAmortized!0 (enqueue!0 queue!7 elem!4)) (not (isEmpty!2 (enqueue!0 queue!7 elem!4)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!71 (Cons!113 (head!160 (_ BitVec 32)) (tail!166 List!71)) (Nil!113))))

(declare-datatypes () ((AbsQueue!28 (Queue!28 (front!35 List!71) (rear!34 List!71)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!28)) Bool (ite (and (is-Queue!28 queue!2) (is-Nil!113 (front!35 queue!2)) (is-Nil!113 (rear!34 queue!2))) true false))

(declare-const queue!8 AbsQueue!28)

(define-fun-rec size!2 ((list!0 List!71)) Int (let ((x$1!6 (ite (is-Nil!113 list!0) 0 (+ 1 (size!2 (tail!166 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!71)) (Set (_ BitVec 32)) (ite (is-Nil!113 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!160 l!21)) (content!4 (tail!166 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!71) (l2!10 List!71)) List!71 (let ((res!35 (ite (is-Nil!113 l1!12) l2!10 (Cons!113 (head!160 l1!12) (concat!0 (tail!166 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!71)) List!71 (let ((x$2!4 (ite (is-Nil!113 l!22) Nil!113 (concat!0 (reverse!1 (tail!166 l!22)) (Cons!113 (head!160 l!22) Nil!113))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!28)) Bool (>= (size!2 (front!35 queue!1)) (size!2 (rear!34 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!71) (rear!3 List!71)) AbsQueue!28 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!28 front!3 rear!3) (Queue!28 (concat!0 front!3 (reverse!1 rear!3)) Nil!113)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!28) (elem!1 (_ BitVec 32))) AbsQueue!28 (let ((x$4!1 (amortizedQueue!0 (front!35 queue!3) (Cons!113 elem!1 (rear!34 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!28)) (_ BitVec 32) (head!160 (front!35 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!28)) AbsQueue!28 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!166 (front!35 queue!4)) (rear!34 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (and (isAmortized!0 q4!0) (not (isEmpty!2 q4!0)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!5 (KeyValuePair!5 (key!13 (_ BitVec 32)) (value!44 (_ BitVec 32))))))

(declare-datatypes () ((List!74 (Cons!116 (head!163 KeyValuePairAbs!5) (tail!169 List!74)) (Nil!116))))

(declare-const l2!11 List!74)

(assert (not (or (is-Nil!116 l2!11) (is-Cons!116 l2!11))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!7 (KeyValuePair!7 (key!15 (_ BitVec 32)) (value!46 (_ BitVec 32))))))

(declare-datatypes () ((List!76 (Cons!118 (head!165 KeyValuePairAbs!7) (tail!171 List!76)) (Nil!118))))

(declare-const l!26 List!76)

(assert (not (or (is-Nil!118 l!26) (and (is-Cons!118 l!26) (is-KeyValuePair!7 (head!165 l!26))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!9 (KeyValuePair!9 (key!17 (_ BitVec 32)) (value!48 (_ BitVec 32))))))

(declare-datatypes () ((List!79 (Cons!121 (head!168 KeyValuePairAbs!9) (tail!174 List!79)) (Nil!121))))

(declare-const l!25 List!79)

(assert (not (or (is-Nil!121 l!25) (and (is-Cons!121 l!25) (is-KeyValuePair!9 (head!168 l!25))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!78 (Cons!120 (head!167 (_ BitVec 32)) (tail!173 List!78)) (Nil!120))))

(declare-const l!22 List!78)

(assert (not (or (is-Nil!120 l!22) (is-Cons!120 l!22))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!11 (KeyValuePair!11 (key!19 (_ BitVec 32)) (value!50 (_ BitVec 32))))))

(declare-datatypes () ((List!82 (Cons!124 (head!171 KeyValuePairAbs!11) (tail!177 List!82)) (Nil!124))))

(declare-const l!26 List!82)

(declare-const e!6 KeyValuePairAbs!11)

(assert (not (=> (and (not (is-Nil!124 l!26)) (is-Cons!124 l!26) (is-KeyValuePair!11 (head!171 l!26))) (let ((k!5 (key!19 (head!171 l!26)))) (let ((v!10 (value!50 (head!171 l!26)))) (let ((xs!32 (tail!177 l!26))) (is-KeyValuePair!11 e!6)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!13 (KeyValuePair!13 (key!21 (_ BitVec 32)) (value!52 (_ BitVec 32))))))

(declare-datatypes () ((List!84 (Cons!126 (head!173 KeyValuePairAbs!13) (tail!179 List!84)) (Nil!126))))

(declare-const l!27 List!84)

(declare-datatypes () ((OptionInt!2 (None!9) (Some!9 (i!118 (_ BitVec 32))))))

(define-fun-rec find!1 ((l!24 List!84) (e!5 (_ BitVec 32))) OptionInt!2 (ite (is-Nil!126 l!24) None!9 (ite (= (key!21 (head!173 l!24)) e!5) (Some!9 (value!52 (head!173 l!24))) (find!1 (tail!179 l!24) e!5))))

(define-fun-rec domain!0 ((l!23 List!84)) (Set (_ BitVec 32)) (ite (is-Nil!126 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!21 (head!173 l!23))) (domain!0 (tail!179 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!84) (e!6 KeyValuePairAbs!13)) List!84 (let ((res!41 (ite (is-Nil!126 l!26) (Cons!126 e!6 Nil!126) (ite (= (key!21 e!6) (key!21 (head!173 l!26))) (Cons!126 (KeyValuePair!13 (key!21 e!6) (value!52 e!6)) (tail!179 l!26)) (Cons!126 (KeyValuePair!13 (key!21 (head!173 l!26)) (value!52 (head!173 l!26))) (updateElem!0 (tail!179 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!21 e!6)))) res!41)))

(declare-const k2!0 (_ BitVec 32))

(declare-const e!7 (_ BitVec 32))

(declare-const k1!0 (_ BitVec 32))

(assert (not (=> (and (is-Cons!126 l!27) (= (find!1 (updateElem!0 (tail!179 l!27) (KeyValuePair!13 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!9 e!7) (find!1 (tail!179 l!27) k1!0)))) (= (find!1 (updateElem!0 l!27 (KeyValuePair!13 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!9 e!7) (find!1 l!27 k1!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!86 (Cons!128 (head!175 (_ BitVec 32)) (tail!181 List!86)) (Nil!128))))

(declare-const l1!12 List!86)

(declare-const l2!10 List!86)

(define-fun-rec size!2 ((list!0 List!86)) Int (let ((x$1!6 (ite (is-Nil!128 list!0) 0 (+ 1 (size!2 (tail!181 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!86)) (Set (_ BitVec 32)) (ite (is-Nil!128 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!175 l!21)) (content!4 (tail!181 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!86) (l2!10 List!86)) List!86 (let ((res!35 (ite (is-Nil!128 l1!12) l2!10 (Cons!128 (head!175 l1!12) (concat!0 (tail!181 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(assert (not (let ((res!283 (ite (is-Nil!128 l1!12) l2!10 (Cons!128 (head!175 l1!12) (concat!0 (tail!181 l1!12) l2!10))))) (and (= (size!2 res!283) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!283) (union (content!4 l1!12) (content!4 l2!10)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!15 (KeyValuePair!15 (key!23 (_ BitVec 32)) (value!54 (_ BitVec 32))))))

(declare-datatypes () ((List!88 (Cons!130 (head!177 KeyValuePairAbs!15) (tail!183 List!88)) (Nil!130))))

(declare-const l!26 List!88)

(declare-const e!6 KeyValuePairAbs!15)

(define-fun-rec domain!0 ((l!23 List!88)) (Set (_ BitVec 32)) (ite (is-Nil!130 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!23 (head!177 l!23))) (domain!0 (tail!183 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!88) (e!6 KeyValuePairAbs!15)) List!88 (let ((res!41 (ite (is-Nil!130 l!26) (Cons!130 e!6 Nil!130) (ite (= (key!23 e!6) (key!23 (head!177 l!26))) (Cons!130 (KeyValuePair!15 (key!23 e!6) (value!54 e!6)) (tail!183 l!26)) (Cons!130 (KeyValuePair!15 (key!23 (head!177 l!26)) (value!54 (head!177 l!26))) (updateElem!0 (tail!183 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!23 e!6)))) res!41)))

(assert (not (let ((res!41 (ite (is-Nil!130 l!26) (Cons!130 e!6 Nil!130) (ite (= (key!23 e!6) (key!23 (head!177 l!26))) (Cons!130 (KeyValuePair!15 (key!23 e!6) (value!54 e!6)) (tail!183 l!26)) (Cons!130 (KeyValuePair!15 (key!23 (head!177 l!26)) (value!54 (head!177 l!26))) (updateElem!0 (tail!183 l!26) e!6)))))) (is-KeyValuePair!15 e!6))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!17 (KeyValuePair!17 (key!25 (_ BitVec 32)) (value!56 (_ BitVec 32))))))

(declare-datatypes () ((List!90 (Cons!132 (head!179 KeyValuePairAbs!17) (tail!185 List!90)) (Nil!132))))

(declare-const l!23 List!90)

(assert (not (or (is-Nil!132 l!23) (and (is-Cons!132 l!23) (is-KeyValuePair!17 (head!179 l!23))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!19 (KeyValuePair!19 (key!27 (_ BitVec 32)) (value!58 (_ BitVec 32))))))

(declare-datatypes () ((List!92 (Cons!134 (head!181 KeyValuePairAbs!19) (tail!187 List!92)) (Nil!134))))

(declare-const l!24 List!92)

(assert (not (or (is-Nil!134 l!24) (and (is-Cons!134 l!24) (is-KeyValuePair!19 (head!181 l!24))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!94 (Cons!136 (head!183 (_ BitVec 32)) (tail!189 List!94)) (Nil!136))))

(declare-const l!21 List!94)

(assert (not (or (is-Nil!136 l!21) (is-Cons!136 l!21))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!96 (Cons!138 (head!185 (_ BitVec 32)) (tail!191 List!96)) (Nil!138))))

(declare-datatypes () ((AbsQueue!31 (Queue!31 (front!38 List!96) (rear!37 List!96)))))

(declare-const queue!1 AbsQueue!31)

(assert (not (is-Queue!31 queue!1)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!51 (fun2!52 (f!554 (=> A1!271 A2!189 R!294)) (pre!380 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!51 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!51 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!554 f!32) x!77 y!9) (@ (f!554 f!32) y!9 x!77))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!554 (fun2!52 (pre!380 f!35) (lambda ((x!902 Int) (x!903 Int)) true))) x!657 x!658)) (isCommutative!0 f!35)) (forall ((x!655 Int)(x!656 Int)) (@ (f!554 (fun2!52 (pre!380 f!35) (lambda ((x!904 Int) (x!905 Int)) true))) x!655 x!656)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!98 (Cons!140 (head!187 (_ BitVec 32)) (tail!193 List!98)) (Nil!140))))

(declare-const l1!12 List!98)

(assert (not (or (is-Nil!140 l1!12) (is-Cons!140 l1!12))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!100 (Cons!142 (head!189 (_ BitVec 32)) (tail!195 List!100)) (Nil!142))))

(declare-const list!0 List!100)

(define-fun-rec size!2 ((list!0 List!100)) Int (let ((x$1!6 (ite (is-Nil!142 list!0) 0 (+ 1 (size!2 (tail!195 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(assert (not (let ((x$1!77 (ite (is-Nil!142 list!0) 0 (+ 1 (size!2 (tail!195 list!0)))))) (>= x$1!77 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!55 (fun2!56 (f!557 (=> A1!271 A2!189 R!294)) (pre!382 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!55 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!55 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!557 f!32) x!77 y!9) (@ (f!557 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!55 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!557 f!33) (@ (f!557 f!33) x!78 y!10) z!10) (@ (f!557 f!33) (@ (f!557 f!33) y!10 z!10) x!78))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!557 (fun2!56 (pre!382 f!35) (lambda ((x!928 Int) (x!929 Int)) true))) x!657 x!658)) (isCommutative!0 f!35) (isRotate!0 f!35)) (forall ((x!649 Int)(x!650 Int)) (@ (f!557 (fun2!56 (pre!382 f!35) (lambda ((x!930 Int) (x!931 Int)) true))) x!649 x!650)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((KeyValuePairAbs!21 (KeyValuePair!21 (key!29 (_ BitVec 32)) (value!60 (_ BitVec 32))))))

(declare-datatypes () ((List!102 (Cons!144 (head!191 KeyValuePairAbs!21) (tail!197 List!102)) (Nil!144))))

(declare-const l!27 List!102)

(declare-datatypes () ((OptionInt!4 (None!11) (Some!11 (i!120 (_ BitVec 32))))))

(define-fun-rec find!1 ((l!24 List!102) (e!5 (_ BitVec 32))) OptionInt!4 (ite (is-Nil!144 l!24) None!11 (ite (= (key!29 (head!191 l!24)) e!5) (Some!11 (value!60 (head!191 l!24))) (find!1 (tail!197 l!24) e!5))))

(define-fun-rec domain!0 ((l!23 List!102)) (Set (_ BitVec 32)) (ite (is-Nil!144 l!23) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (key!29 (head!191 l!23))) (domain!0 (tail!197 l!23)))))

(define-fun-rec updateElem!0 ((l!26 List!102) (e!6 KeyValuePairAbs!21)) List!102 (let ((res!41 (ite (is-Nil!144 l!26) (Cons!144 e!6 Nil!144) (ite (= (key!29 e!6) (key!29 (head!191 l!26))) (Cons!144 (KeyValuePair!21 (key!29 e!6) (value!60 e!6)) (tail!197 l!26)) (Cons!144 (KeyValuePair!21 (key!29 (head!191 l!26)) (value!60 (head!191 l!26))) (updateElem!0 (tail!197 l!26) e!6)))))) (assume (= (domain!0 res!41) (union (domain!0 l!26) (insert (as emptyset (_ BitVec 32)) (key!29 e!6)))) res!41)))

(declare-const k2!0 (_ BitVec 32))

(declare-const e!7 (_ BitVec 32))

(declare-const k1!0 (_ BitVec 32))

(assert (not (=> (is-Nil!144 l!27) (= (find!1 (updateElem!0 l!27 (KeyValuePair!21 k2!0 e!7)) k1!0) (ite (= k1!0 k2!0) (Some!11 e!7) (find!1 l!27 k1!0))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!103 (Cons!145 (head!192 (_ BitVec 32)) (tail!198 List!103)) (Nil!145))))

(declare-const list!0 List!103)

(assert (not (or (is-Nil!145 list!0) (is-Cons!145 list!0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!106 (Cons!148 (head!195 (_ BitVec 32)) (tail!201 List!106)) (Nil!148))))

(declare-datatypes () ((AbsQueue!33 (Queue!33 (front!40 List!106) (rear!39 List!106)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!33)) Bool (ite (and (is-Queue!33 queue!2) (is-Nil!148 (front!40 queue!2)) (is-Nil!148 (rear!39 queue!2))) true false))

(declare-const queue!7 AbsQueue!33)

(define-fun front!5 ((queue!5 AbsQueue!33)) (_ BitVec 32) (head!195 (front!40 queue!5)))

(define-fun-rec size!2 ((list!0 List!106)) Int (let ((x$1!6 (ite (is-Nil!148 list!0) 0 (+ 1 (size!2 (tail!201 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!106)) (Set (_ BitVec 32)) (ite (is-Nil!148 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!195 l!21)) (content!4 (tail!201 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!106) (l2!10 List!106)) List!106 (let ((res!35 (ite (is-Nil!148 l1!12) l2!10 (Cons!148 (head!195 l1!12) (concat!0 (tail!201 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!106)) List!106 (let ((x$2!4 (ite (is-Nil!148 l!22) Nil!148 (concat!0 (reverse!1 (tail!201 l!22)) (Cons!148 (head!195 l!22) Nil!148))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!33)) Bool (>= (size!2 (front!40 queue!1)) (size!2 (rear!39 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!106) (rear!3 List!106)) AbsQueue!33 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!33 front!3 rear!3) (Queue!33 (concat!0 front!3 (reverse!1 rear!3)) Nil!148)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!33) (elem!1 (_ BitVec 32))) AbsQueue!33 (let ((x$4!1 (amortizedQueue!0 (front!40 queue!3) (Cons!148 elem!1 (rear!39 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const elem!4 (_ BitVec 32))

(assert (not (ite (isEmpty!2 queue!7) (= (front!5 (enqueue!0 queue!7 elem!4)) elem!4) true)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!59 (fun2!60 (f!561 (=> A1!271 A2!189 R!294)) (pre!384 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!59 Int Int Int))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!59 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!561 f!32) x!77 y!9) (@ (f!561 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!59 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!561 f!33) (@ (f!561 f!33) x!78 y!10) z!10) (@ (f!561 f!33) (@ (f!561 f!33) y!10 z!10) x!78))))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!59 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!561 f!31) (@ (f!561 f!31) x!76 y!8) z!9) (@ (f!561 f!31) x!76 (@ (f!561 f!31) y!8 z!9)))))))

(assert (not (=> (and (forall ((x!657 Int)(x!658 Int)) (@ (f!561 (fun2!60 (pre!384 f!35) (lambda ((x!963 Int) (x!964 Int)) true))) x!657 x!658)) (isCommutative!0 f!35) (isRotate!0 f!35)) (isAssociative!0 f!35))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!63 (fun2!64 (f!566 (=> A1!271 A2!189 R!294)) (pre!386 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!63 A!40 A!40 A!40))))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!566 (fun2!64 (pre!386 (as f!33 (fun2!63 A!40 A!40 A!40))) (lambda ((x!975 A!40) (x!976 A!40)) true))) x!655 x!656)) (@ (f!566 (fun2!64 (pre!386 (as f!33 (fun2!63 A!40 A!40 A!40))) (lambda ((x!977 A!40) (x!978 A!40)) true))) (as y!10 A!40) (as z!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!68 (fun2!69 (f!579 (=> A1!271 A2!189 R!294)) (pre!399 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!68 A!39 A!39 A!39))))

(declare-const (par (A!39) (x!645 A!39)))

(declare-const (par (A!39) (x!646 A!39)))

(assert (par (A!39) (not (@ (f!579 (fun2!69 (pre!399 (fun2!69 (pre!399 (as f!32 (fun2!68 A!39 A!39 A!39))) (lambda ((x!1011 A!39) (x!1012 A!39)) true))) (lambda ((x!1013 A!39) (x!1014 A!39)) true))) (as x!645 A!39) (as x!646 A!39)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!198 (array!199 (arr!100 (Array (_ BitVec 32) A!297)) (size!142 (_ BitVec 32))))))

(declare-const arr!0 (array!198 (_ BitVec 32)))

(declare-const x!83 (_ BitVec 32))

(datatype-invariant (par (A!296) array!197 (array!198 A!296) (bvsge (size!142 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!142 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (let ((y!13 (assume (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!142 arr!0))) (select (arr!100 arr!0) i!22)))) (=> (and (not (= x!83 y!13)) (bvslt x!83 y!13)) (and (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd (bvsub i!22 #b00000000000000000000000000000001) #b00000000000000000000000000000001))) (bvslt (bvsub i!22 #b00000000000000000000000000000001) (size!142 arr!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!72 (fun2!73 (f!581 (=> A1!271 A2!189 R!294)) (pre!401 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!72 A!39 A!39 A!39))))

(declare-const (par (A!39) (x!77 A!39)))

(declare-const (par (A!39) (y!9 A!39)))

(assert (par (A!39) (not (=> (forall ((x!645 A!39)(x!646 A!39)) (@ (f!581 (fun2!73 (pre!401 (as f!32 (fun2!72 A!39 A!39 A!39))) (lambda ((x!1023 A!39) (x!1024 A!39)) true))) x!645 x!646)) (@ (f!581 (fun2!73 (pre!401 (as f!32 (fun2!72 A!39 A!39 A!39))) (lambda ((x!1025 A!39) (x!1026 A!39)) true))) (as x!77 A!39) (as y!9 A!39))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!76 (fun2!77 (f!583 (=> A1!271 A2!189 R!294)) (pre!403 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!39) (f!32 (fun2!76 A!39 A!39 A!39))))

(declare-const (par (A!39) (y!9 A!39)))

(declare-const (par (A!39) (x!77 A!39)))

(assert (par (A!39) (not (=> (forall ((x!645 A!39)(x!646 A!39)) (@ (f!583 (fun2!77 (pre!403 (as f!32 (fun2!76 A!39 A!39 A!39))) (lambda ((x!1039 A!39) (x!1040 A!39)) true))) x!645 x!646)) (@ (f!583 (fun2!77 (pre!403 (as f!32 (fun2!76 A!39 A!39 A!39))) (lambda ((x!1041 A!39) (x!1042 A!39)) true))) (as y!9 A!39) (as x!77 A!39))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!80 (fun2!81 (f!585 (=> A1!271 A2!189 R!294)) (pre!405 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!80 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!649 A!38)))

(declare-const (par (A!38) (x!650 A!38)))

(assert (par (A!38) (not (@ (f!585 (fun2!81 (pre!405 (fun2!81 (pre!405 (as f!31 (fun2!80 A!38 A!38 A!38))) (lambda ((x!1052 A!38) (x!1053 A!38)) true))) (lambda ((x!1054 A!38) (x!1055 A!38)) true))) (as x!649 A!38) (as x!650 A!38)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!108 (Cons!152 (head!199 (_ BitVec 32)) (tail!205 List!108)) (Nil!152))))

(declare-datatypes () ((AbsQueue!35 (Queue!35 (front!42 List!108) (rear!41 List!108)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!35)) Bool (ite (and (is-Queue!35 queue!2) (is-Nil!152 (front!42 queue!2)) (is-Nil!152 (rear!41 queue!2))) true false))

(declare-const queue!8 AbsQueue!35)

(define-fun-rec size!2 ((list!0 List!108)) Int (let ((x$1!6 (ite (is-Nil!152 list!0) 0 (+ 1 (size!2 (tail!205 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!108)) (Set (_ BitVec 32)) (ite (is-Nil!152 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!199 l!21)) (content!4 (tail!205 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!108) (l2!10 List!108)) List!108 (let ((res!35 (ite (is-Nil!152 l1!12) l2!10 (Cons!152 (head!199 l1!12) (concat!0 (tail!205 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!108)) List!108 (let ((x$2!4 (ite (is-Nil!152 l!22) Nil!152 (concat!0 (reverse!1 (tail!205 l!22)) (Cons!152 (head!199 l!22) Nil!152))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!35)) Bool (>= (size!2 (front!42 queue!1)) (size!2 (rear!41 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!108) (rear!3 List!108)) AbsQueue!35 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!35 front!3 rear!3) (Queue!35 (concat!0 front!3 (reverse!1 rear!3)) Nil!152)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!35) (elem!1 (_ BitVec 32))) AbsQueue!35 (let ((x$4!1 (amortizedQueue!0 (front!42 queue!3) (Cons!152 elem!1 (rear!41 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!35)) (_ BitVec 32) (head!199 (front!42 queue!5)))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (and (isAmortized!0 q3!0) (not (isEmpty!2 q3!0))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!5 (Leaf!4) (Node!9 (left!35 Tree!5) (value!64 Int) (right!37 Tree!5)))))

(declare-const v!14 Int)

(define-fun-rec content!5 ((tree!0 Tree!5)) (Set Int) (ite (is-Leaf!4 tree!0) (as emptyset Int) (union (union (content!5 (left!35 tree!0)) (insert (as emptyset Int) (value!64 tree!0))) (content!5 (right!37 tree!0)))))

(assert (not (let ((x$1!83 (Node!9 Leaf!4 v!14 Leaf!4))) (= (content!5 x$1!83) (insert (as emptyset Int) v!14)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!85 (fun2!86 (f!598 (=> A1!271 A2!189 R!294)) (pre!418 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!85 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!598 (fun2!86 (pre!418 (as f!31 (fun2!85 A!38 A!38 A!38))) (lambda ((x!1065 A!38) (x!1066 A!38)) true))) x!649 x!650)) (@ (f!598 (fun2!86 (pre!418 (as f!31 (fun2!85 A!38 A!38 A!38))) (lambda ((x!1067 A!38) (x!1068 A!38)) true))) (@ (f!598 (as f!31 (fun2!85 A!38 A!38 A!38))) (as x!76 A!38) (as y!8 A!38)) (as z!9 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!110 (Cons!154 (head!201 (_ BitVec 32)) (tail!207 List!110)) (Nil!154))))

(declare-datatypes () ((AbsQueue!37 (Queue!37 (front!44 List!110) (rear!43 List!110)))))

(define-fun-rec size!2 ((list!0 List!110)) Int (let ((x$1!6 (ite (is-Nil!154 list!0) 0 (+ 1 (size!2 (tail!207 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!110)) (Set (_ BitVec 32)) (ite (is-Nil!154 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!201 l!21)) (content!4 (tail!207 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!110) (l2!10 List!110)) List!110 (let ((res!35 (ite (is-Nil!154 l1!12) l2!10 (Cons!154 (head!201 l1!12) (concat!0 (tail!207 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!110)) List!110 (let ((x$2!4 (ite (is-Nil!154 l!22) Nil!154 (concat!0 (reverse!1 (tail!207 l!22)) (Cons!154 (head!201 l!22) Nil!154))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!37)) List!110 (concat!0 (front!44 queue!0) (reverse!1 (rear!43 queue!0))))

(declare-const front!6 List!110)

(declare-const rear!6 List!110)

(declare-const list!2 List!110)

(define-fun isEmpty!2 ((queue!2 AbsQueue!37)) Bool (ite (and (is-Queue!37 queue!2) (is-Nil!154 (front!44 queue!2)) (is-Nil!154 (rear!43 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!37)) Bool (>= (size!2 (front!44 queue!1)) (size!2 (rear!43 queue!1))))

(assert (not (=> (and (= (asList!0 (Queue!37 front!6 rear!6)) list!2) (is-Cons!154 list!2)) (let ((xs!27 (tail!207 list!2))) (=> (and (is-Cons!154 rear!6) (not (isEmpty!2 (Queue!37 front!6 rear!6))) (isAmortized!0 (Queue!37 front!6 rear!6)) (=> (and (= (asList!0 (Queue!37 front!6 (tail!207 rear!6))) list!2) (is-Cons!154 list!2)) (let ((xs!108 (tail!207 list!2))) (and (isAmortized!0 (Queue!37 front!6 (tail!207 rear!6))) (not (isEmpty!2 (Queue!37 front!6 (tail!207 rear!6)))))))) (and (isAmortized!0 (Queue!37 front!6 rear!6)) (not (isEmpty!2 (Queue!37 front!6 rear!6)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!89 (fun2!90 (f!600 (=> A1!271 A2!189 R!294)) (pre!420 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!89 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!600 (fun2!90 (pre!420 (as f!31 (fun2!89 A!38 A!38 A!38))) (lambda ((x!1081 A!38) (x!1082 A!38)) true))) x!649 x!650)) (@ (f!600 (fun2!90 (pre!420 (as f!31 (fun2!89 A!38 A!38 A!38))) (lambda ((x!1083 A!38) (x!1084 A!38)) true))) (as x!76 A!38) (as y!8 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!7 (Leaf!6) (Node!11 (left!37 Tree!7) (value!66 Int) (right!39 Tree!7)))))

(define-fun-rec content!5 ((tree!0 Tree!7)) (Set Int) (ite (is-Leaf!6 tree!0) (as emptyset Int) (union (union (content!5 (left!37 tree!0)) (insert (as emptyset Int) (value!66 tree!0))) (content!5 (right!39 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!7)) Bool (ite (is-Leaf!6 tree!1) true (and (and (and (isBST!0 (left!37 tree!1)) (isBST!0 (right!39 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!37 tree!1))) (< x!84 (value!66 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!39 tree!1))) (< (value!66 tree!1) x!85))))))

(declare-const tree!2 Tree!7)

(declare-const value!2 Int)

(assert (not (=> (and (isBST!0 tree!2) (not (is-Leaf!6 tree!2)) (is-Node!11 tree!2)) (let ((l!29 (left!37 tree!2))) (let ((v!13 (value!66 tree!2))) (let ((r!10 (right!39 tree!2))) (=> (< v!13 value!2) (isBST!0 r!10))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!93 (fun2!94 (f!602 (=> A1!271 A2!189 R!294)) (pre!422 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!93 A!38 A!38 A!38))))

(declare-const (par (A!38) (x!76 A!38)))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!602 (fun2!94 (pre!422 (as f!31 (fun2!93 A!38 A!38 A!38))) (lambda ((x!1097 A!38) (x!1098 A!38)) true))) x!649 x!650)) (@ (f!602 (fun2!94 (pre!422 (as f!31 (fun2!93 A!38 A!38 A!38))) (lambda ((x!1099 A!38) (x!1100 A!38)) true))) (as x!76 A!38) (@ (f!602 (as f!31 (fun2!93 A!38 A!38 A!38))) (as y!8 A!38) (as z!9 A!38)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!97 (fun2!98 (f!604 (=> A1!271 A2!189 R!294)) (pre!424 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!38) (f!31 (fun2!97 A!38 A!38 A!38))))

(declare-const (par (A!38) (y!8 A!38)))

(declare-const (par (A!38) (z!9 A!38)))

(assert (par (A!38) (not (=> (forall ((x!649 A!38)(x!650 A!38)) (@ (f!604 (fun2!98 (pre!424 (as f!31 (fun2!97 A!38 A!38 A!38))) (lambda ((x!1110 A!38) (x!1111 A!38)) true))) x!649 x!650)) (@ (f!604 (fun2!98 (pre!424 (as f!31 (fun2!97 A!38 A!38 A!38))) (lambda ((x!1112 A!38) (x!1113 A!38)) true))) (as y!8 A!38) (as z!9 A!38))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!101 (fun2!102 (f!606 (=> A1!271 A2!189 R!294)) (pre!426 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!101 Int Int Int))

(declare-const x!657 Int)

(declare-const x!658 Int)

(assert (not (@ (f!606 (fun2!102 (pre!426 (fun2!102 (pre!426 f!35) (lambda ((x!1114 Int) (x!1115 Int)) true))) (lambda ((x!1116 Int) (x!1117 Int)) true))) x!657 x!658)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!112 (Cons!156 (head!203 (_ BitVec 32)) (tail!209 List!112)) (Nil!156))))

(declare-datatypes () ((AbsQueue!39 (Queue!39 (front!46 List!112) (rear!45 List!112)))))

(define-fun-rec size!2 ((list!0 List!112)) Int (let ((x$1!6 (ite (is-Nil!156 list!0) 0 (+ 1 (size!2 (tail!209 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!112)) (Set (_ BitVec 32)) (ite (is-Nil!156 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!203 l!21)) (content!4 (tail!209 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!112) (l2!10 List!112)) List!112 (let ((res!35 (ite (is-Nil!156 l1!12) l2!10 (Cons!156 (head!203 l1!12) (concat!0 (tail!209 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!112)) List!112 (let ((x$2!4 (ite (is-Nil!156 l!22) Nil!156 (concat!0 (reverse!1 (tail!209 l!22)) (Cons!156 (head!203 l!22) Nil!156))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun asList!0 ((queue!0 AbsQueue!39)) List!112 (concat!0 (front!46 queue!0) (reverse!1 (rear!45 queue!0))))

(declare-const front!6 List!112)

(declare-const rear!6 List!112)

(declare-const list!2 List!112)

(define-fun isEmpty!2 ((queue!2 AbsQueue!39)) Bool (ite (and (is-Queue!39 queue!2) (is-Nil!156 (front!46 queue!2)) (is-Nil!156 (rear!45 queue!2))) true false))

(define-fun isAmortized!0 ((queue!1 AbsQueue!39)) Bool (>= (size!2 (front!46 queue!1)) (size!2 (rear!45 queue!1))))

(assert (not (=> (and (= (asList!0 (Queue!39 front!6 rear!6)) list!2) (is-Cons!156 list!2)) (let ((xs!27 (tail!209 list!2))) (=> (and (is-Nil!156 rear!6) (not (isEmpty!2 (Queue!39 front!6 rear!6))) (isAmortized!0 (Queue!39 front!6 rear!6))) (and (isAmortized!0 (Queue!39 front!6 rear!6)) (not (isEmpty!2 (Queue!39 front!6 rear!6)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!105 (fun2!106 (f!608 (=> A1!271 A2!189 R!294)) (pre!428 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!105 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!655 A!40)))

(declare-const (par (A!40) (x!656 A!40)))

(assert (par (A!40) (not (@ (f!608 (fun2!106 (pre!428 (fun2!106 (pre!428 (as f!33 (fun2!105 A!40 A!40 A!40))) (lambda ((x!1143 A!40) (x!1144 A!40)) true))) (lambda ((x!1145 A!40) (x!1146 A!40)) true))) (as x!655 A!40) (as x!656 A!40)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!9 (Leaf!8) (Node!13 (left!39 Tree!9) (value!68 Int) (right!41 Tree!9)))))

(define-fun-rec content!5 ((tree!0 Tree!9)) (Set Int) (ite (is-Leaf!8 tree!0) (as emptyset Int) (union (union (content!5 (left!39 tree!0)) (insert (as emptyset Int) (value!68 tree!0))) (content!5 (right!41 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!9)) Bool (ite (is-Leaf!8 tree!1) true (and (and (and (isBST!0 (left!39 tree!1)) (isBST!0 (right!41 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!39 tree!1))) (< x!84 (value!68 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!41 tree!1))) (< (value!68 tree!1) x!85))))))

(declare-const tree!2 Tree!9)

(declare-const value!2 Int)

(assert (not (=> (and (isBST!0 tree!2) (not (is-Leaf!8 tree!2)) (is-Node!13 tree!2)) (let ((l!29 (left!39 tree!2))) (let ((v!13 (value!68 tree!2))) (let ((r!10 (right!41 tree!2))) (=> (and (>= v!13 value!2) (> v!13 value!2)) (isBST!0 l!29))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!109 (fun2!110 (f!610 (=> A1!271 A2!189 R!294)) (pre!430 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!109 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!78 A!40)))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!610 (fun2!110 (pre!430 (as f!33 (fun2!109 A!40 A!40 A!40))) (lambda ((x!1153 A!40) (x!1154 A!40)) true))) x!655 x!656)) (@ (f!610 (fun2!110 (pre!430 (as f!33 (fun2!109 A!40 A!40 A!40))) (lambda ((x!1155 A!40) (x!1156 A!40)) true))) (@ (f!610 (as f!33 (fun2!109 A!40 A!40 A!40))) (as x!78 A!40) (as y!10 A!40)) (as z!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!113 (fun2!114 (f!612 (=> A1!271 A2!189 R!294)) (pre!432 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!113 A!40 A!40 A!40))))

(declare-const (par (A!40) (x!78 A!40)))

(declare-const (par (A!40) (y!10 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!612 (fun2!114 (pre!432 (as f!33 (fun2!113 A!40 A!40 A!40))) (lambda ((x!1168 A!40) (x!1169 A!40)) true))) x!655 x!656)) (@ (f!612 (fun2!114 (pre!432 (as f!33 (fun2!113 A!40 A!40 A!40))) (lambda ((x!1170 A!40) (x!1171 A!40)) true))) (as x!78 A!40) (as y!10 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!117 (fun2!118 (f!614 (=> A1!271 A2!189 R!294)) (pre!434 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!40) (f!33 (fun2!117 A!40 A!40 A!40))))

(declare-const (par (A!40) (y!10 A!40)))

(declare-const (par (A!40) (z!10 A!40)))

(declare-const (par (A!40) (x!78 A!40)))

(assert (par (A!40) (not (=> (forall ((x!655 A!40)(x!656 A!40)) (@ (f!614 (fun2!118 (pre!434 (as f!33 (fun2!117 A!40 A!40 A!40))) (lambda ((x!1181 A!40) (x!1182 A!40)) true))) x!655 x!656)) (@ (f!614 (fun2!118 (pre!434 (as f!33 (fun2!117 A!40 A!40 A!40))) (lambda ((x!1183 A!40) (x!1184 A!40)) true))) (@ (f!614 (as f!33 (fun2!117 A!40 A!40 A!40))) (as y!10 A!40) (as z!10 A!40)) (as x!78 A!40))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!204 (array!205 (arr!103 (Array (_ BitVec 32) A!297)) (size!146 (_ BitVec 32))))))

(declare-const arr!0 (array!204 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!204 A!296) (bvsge (size!146 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!146 arr!0))) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!11 (Leaf!10) (Node!15 (left!41 Tree!11) (value!70 Int) (right!43 Tree!11)))))

(define-fun-rec content!5 ((tree!0 Tree!11)) (Set Int) (ite (is-Leaf!10 tree!0) (as emptyset Int) (union (union (content!5 (left!41 tree!0)) (insert (as emptyset Int) (value!70 tree!0))) (content!5 (right!43 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!11)) Bool (ite (is-Leaf!10 tree!1) true (and (and (and (isBST!0 (left!41 tree!1)) (isBST!0 (right!43 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!41 tree!1))) (< x!84 (value!70 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!43 tree!1))) (< (value!70 tree!1) x!85))))))

(declare-const tree!2 Tree!11)

(declare-const value!2 Int)

(define-fun-rec insert!0 ((tree!2 Tree!11) (value!2 Int)) Tree!11 (assume (isBST!0 tree!2) (let ((res!60 (ite (is-Leaf!10 tree!2) (Node!15 Leaf!10 value!2 Leaf!10) (ite (< (value!70 tree!2) value!2) (Node!15 (left!41 tree!2) (value!70 tree!2) (insert!0 (right!43 tree!2) value!2)) (ite (> (value!70 tree!2) value!2) (Node!15 (insert!0 (left!41 tree!2) value!2) (value!70 tree!2) (right!43 tree!2)) (Node!15 (left!41 tree!2) (value!70 tree!2) (right!43 tree!2))))))) (assume (and (isBST!0 res!60) (= (content!5 res!60) (union (content!5 tree!2) (insert (as emptyset Int) value!2)))) res!60))))

(assert (not (=> (isBST!0 tree!2) (let ((res!378 (ite (is-Leaf!10 tree!2) (Node!15 Leaf!10 value!2 Leaf!10) (ite (< (value!70 tree!2) value!2) (Node!15 (left!41 tree!2) (value!70 tree!2) (insert!0 (right!43 tree!2) value!2)) (ite (> (value!70 tree!2) value!2) (Node!15 (insert!0 (left!41 tree!2) value!2) (value!70 tree!2) (right!43 tree!2)) (Node!15 (left!41 tree!2) (value!70 tree!2) (right!43 tree!2))))))) (and (isBST!0 res!378) (= (content!5 res!378) (union (content!5 tree!2) (insert (as emptyset Int) value!2))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!114 (Cons!159 (head!206 (_ BitVec 32)) (tail!212 List!114)) (Nil!159))))

(declare-datatypes () ((AbsQueue!41 (Queue!41 (front!48 List!114) (rear!47 List!114)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!41)) Bool (ite (and (is-Queue!41 queue!2) (is-Nil!159 (front!48 queue!2)) (is-Nil!159 (rear!47 queue!2))) true false))

(declare-const queue!8 AbsQueue!41)

(define-fun-rec size!2 ((list!0 List!114)) Int (let ((x$1!6 (ite (is-Nil!159 list!0) 0 (+ 1 (size!2 (tail!212 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!114)) (Set (_ BitVec 32)) (ite (is-Nil!159 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!206 l!21)) (content!4 (tail!212 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!114) (l2!10 List!114)) List!114 (let ((res!35 (ite (is-Nil!159 l1!12) l2!10 (Cons!159 (head!206 l1!12) (concat!0 (tail!212 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!114)) List!114 (let ((x$2!4 (ite (is-Nil!159 l!22) Nil!159 (concat!0 (reverse!1 (tail!212 l!22)) (Cons!159 (head!206 l!22) Nil!159))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!41)) Bool (>= (size!2 (front!48 queue!1)) (size!2 (rear!47 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!114) (rear!3 List!114)) AbsQueue!41 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!41 front!3 rear!3) (Queue!41 (concat!0 front!3 (reverse!1 rear!3)) Nil!159)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!41) (elem!1 (_ BitVec 32))) AbsQueue!41 (let ((x$4!1 (amortizedQueue!0 (front!48 queue!3) (Cons!159 elem!1 (rear!47 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!41)) (_ BitVec 32) (head!206 (front!48 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!41)) AbsQueue!41 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!212 (front!48 queue!4)) (rear!47 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (and (isAmortized!0 q4!0) (not (isEmpty!2 q4!0))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!13 (Leaf!12) (Node!17 (left!43 Tree!13) (value!73 Int) (right!45 Tree!13)))))

(define-fun-rec content!6 ((thiss!116 Tree!13)) (Set Int) (ite (is-Leaf!12 thiss!116) (as emptyset Int) (union (union (content!6 (left!43 thiss!116)) (insert (as emptyset Int) (value!73 thiss!116))) (content!6 (right!45 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!13)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!43 thiss!117))) (< x!86 (value!73 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!45 thiss!117))) (< (value!73 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!13)) Bool (ite (is-Node!17 thiss!115) (inv!9 (assume (is-Node!17 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!13 (ite (is-Node!17 thiss!115) (inv!9 (assume (is-Node!17 thiss!115) thiss!115)) true))

(assert (not (inv!41 Leaf!12)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!15 (Leaf!14) (Node!19 (left!45 Tree!15) (value!75 Int) (right!47 Tree!15)))))

(declare-const tree!3 Tree!15)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!15)) (Set Int) (ite (is-Leaf!14 thiss!116) (as emptyset Int) (union (union (content!6 (left!45 thiss!116)) (insert (as emptyset Int) (value!75 thiss!116))) (content!6 (right!47 thiss!116)))))

(define-fun-rec insert!1 ((tree!3 Tree!15) (value!4 Int)) Tree!15 (let ((res!61 (ite (is-Leaf!14 tree!3) (Node!19 Leaf!14 value!4 Leaf!14) (ite (< (value!75 tree!3) value!4) (Node!19 (left!45 tree!3) (value!75 tree!3) (insert!1 (right!47 tree!3) value!4)) (ite (> (value!75 tree!3) value!4) (Node!19 (insert!1 (left!45 tree!3) value!4) (value!75 tree!3) (right!47 tree!3)) (Node!19 (left!45 tree!3) (value!75 tree!3) (right!47 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(define-fun inv!9 ((thiss!117 Tree!15)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!45 thiss!117))) (< x!86 (value!75 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!47 thiss!117))) (< (value!75 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!15 (ite (is-Node!19 thiss!115) (inv!9 (assume (is-Node!19 thiss!115) thiss!115)) true))

(assert (not (let ((res!419 (ite (is-Leaf!14 tree!3) (Node!19 Leaf!14 value!4 Leaf!14) (ite (< (value!75 tree!3) value!4) (Node!19 (left!45 tree!3) (value!75 tree!3) (insert!1 (right!47 tree!3) value!4)) (ite (> (value!75 tree!3) value!4) (Node!19 (insert!1 (left!45 tree!3) value!4) (value!75 tree!3) (right!47 tree!3)) (Node!19 (left!45 tree!3) (value!75 tree!3) (right!47 tree!3))))))) (= (content!6 res!419) (union (content!6 tree!3) (insert (as emptyset Int) value!4))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!210 (array!211 (arr!106 (Array (_ BitVec 32) A!297)) (size!149 (_ BitVec 32))))))

(declare-const arr!0 (array!210 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!210 A!296) (bvsge (size!149 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!149 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!214 (array!215 (arr!108 (Array (_ BitVec 32) A!297)) (size!151 (_ BitVec 32))))))

(declare-const arr!0 (array!214 (_ BitVec 32)))

(datatype-invariant (par (A!296) array!197 (array!214 A!296) (bvsge (size!151 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!151 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!151 arr!0)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!116 (Cons!161 (head!208 (_ BitVec 32)) (tail!214 List!116)) (Nil!161))))

(declare-datatypes () ((AbsQueue!43 (Queue!43 (front!50 List!116) (rear!49 List!116)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!43)) Bool (ite (and (is-Queue!43 queue!2) (is-Nil!161 (front!50 queue!2)) (is-Nil!161 (rear!49 queue!2))) true false))

(declare-const queue!8 AbsQueue!43)

(define-fun-rec size!2 ((list!0 List!116)) Int (let ((x$1!6 (ite (is-Nil!161 list!0) 0 (+ 1 (size!2 (tail!214 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!116)) (Set (_ BitVec 32)) (ite (is-Nil!161 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!208 l!21)) (content!4 (tail!214 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!116) (l2!10 List!116)) List!116 (let ((res!35 (ite (is-Nil!161 l1!12) l2!10 (Cons!161 (head!208 l1!12) (concat!0 (tail!214 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!116)) List!116 (let ((x$2!4 (ite (is-Nil!161 l!22) Nil!161 (concat!0 (reverse!1 (tail!214 l!22)) (Cons!161 (head!208 l!22) Nil!161))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!43)) Bool (>= (size!2 (front!50 queue!1)) (size!2 (rear!49 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!116) (rear!3 List!116)) AbsQueue!43 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!43 front!3 rear!3) (Queue!43 (concat!0 front!3 (reverse!1 rear!3)) Nil!161)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!43) (elem!1 (_ BitVec 32))) AbsQueue!43 (let ((x$4!1 (amortizedQueue!0 (front!50 queue!3) (Cons!161 elem!1 (rear!49 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!43)) (_ BitVec 32) (head!208 (front!50 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!43)) AbsQueue!43 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!214 (front!50 queue!4)) (rear!49 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (=> (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (let ((q5!0 (tail!8 q4!0))) (and (isAmortized!0 q5!0) (not (isEmpty!2 q5!0)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const lo!0 (_ BitVec 32))

(declare-const hi!0 (_ BitVec 32))

(declare-datatypes (A!297) ((array!218 (array!219 (arr!110 (Array (_ BitVec 32) A!297)) (size!153 (_ BitVec 32))))))

(declare-const arr!0 (array!218 (_ BitVec 32)))

(declare-const x!83 (_ BitVec 32))

(datatype-invariant (par (A!296) array!197 (array!218 A!296) (bvsge (size!153 array!197) #b00000000000000000000000000000000)))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 lo!0) (bvsle lo!0 (bvadd hi!0 #b00000000000000000000000000000001)) (bvslt hi!0 (size!153 arr!0)) (bvsge (bvadd (bvsub hi!0 lo!0) #b00000000000000000000000000000001) #b00000000000000000000000000000000) (bvsle lo!0 hi!0)) (let ((i!22 (bvadd lo!0 (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvsub hi!0 lo!0) #b00000000000000000000000000000010))))) (let ((y!13 (assume (and (bvsge i!22 #b00000000000000000000000000000000) (bvslt i!22 (size!153 arr!0))) (select (arr!110 arr!0) i!22)))) (=> (and (not (= x!83 y!13)) (bvsge x!83 y!13)) (and (and (bvsle #b00000000000000000000000000000000 (bvadd i!22 #b00000000000000000000000000000001)) (bvsle (bvadd i!22 #b00000000000000000000000000000001) (bvadd hi!0 #b00000000000000000000000000000001))) (bvslt hi!0 (size!153 arr!0)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!122 (fun2!123 (f!627 (=> A1!271 A2!189 R!294)) (pre!447 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!122 A!41 A!41 A!41))))

(declare-const (par (A!41) (x!651 A!41)))

(declare-const (par (A!41) (x!652 A!41)))

(assert (par (A!41) (not (@ (f!627 (fun2!123 (pre!447 (fun2!123 (pre!447 (as f1!0 (fun2!122 A!41 A!41 A!41))) (lambda ((x!1244 A!41) (x!1245 A!41)) true))) (lambda ((x!1246 A!41) (x!1247 A!41)) true))) (as x!651 A!41) (as x!652 A!41)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!126 (fun2!127 (f!629 (=> A1!271 A2!189 R!294)) (pre!449 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!126 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!126 B!30 B!30 B!30))))

(declare-const (par (B!30) (x!653 B!30)))

(declare-const (par (B!30) (x!654 B!30)))

(assert (par (A!41 B!30) (not (=> (forall ((x!651 A!41)(x!652 A!41)) (@ (f!629 (fun2!127 (pre!449 (as f1!0 (fun2!126 A!41 A!41 A!41))) (lambda ((x!1254 A!41) (x!1255 A!41)) true))) x!651 x!652)) (@ (f!629 (fun2!127 (pre!449 (fun2!127 (pre!449 (as f2!1 (fun2!126 B!30 B!30 B!30))) (lambda ((x!1256 B!30) (x!1257 B!30)) true))) (lambda ((x!1258 B!30) (x!1259 B!30)) true))) (as x!653 B!30) (as x!654 B!30))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!132 (fun2!133 (f!632 (=> A1!271 A2!189 R!294)) (pre!452 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!132 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!132 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!132 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!632 f!31) (@ (f!632 f!31) x!76 y!8) z!9) (@ (f!632 f!31) x!76 (@ (f!632 f!31) y!8 z!9)))))))

(declare-datatypes (A0!9 A1!397) ((tuple2!12 (tuple2!13 (_1!6 A0!9) (_2!6 A1!397)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!12 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!12 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!632 (fun2!133 (pre!452 (as f1!0 (fun2!132 A!41 A!41 A!41))) (lambda ((x!1272 A!41) (x!1273 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!632 (fun2!133 (pre!452 (as f2!1 (fun2!132 B!30 B!30 B!30))) (lambda ((x!1274 B!30) (x!1275 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!132 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!132 B!30 B!30 B!30)))) (@ (f!632 (fun2!133 (pre!452 (fun2!133 (pre!452 (as f1!0 (fun2!132 A!41 A!41 A!41))) (lambda ((x!1276 A!41) (x!1277 A!41)) true))) (lambda ((x!1278 A!41) (x!1279 A!41)) true))) (_1!6 (as p1!0 (tuple2!12 A!41 B!30))) (_1!6 (as p2!0 (tuple2!12 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!17 (Leaf!16) (Node!21 (left!47 Tree!17) (value!77 Int) (right!49 Tree!17)))))

(define-fun-rec content!5 ((tree!0 Tree!17)) (Set Int) (ite (is-Leaf!16 tree!0) (as emptyset Int) (union (union (content!5 (left!47 tree!0)) (insert (as emptyset Int) (value!77 tree!0))) (content!5 (right!49 tree!0)))))

(define-fun-rec isBST!0 ((tree!1 Tree!17)) Bool (ite (is-Leaf!16 tree!1) true (and (and (and (isBST!0 (left!47 tree!1)) (isBST!0 (right!49 tree!1))) (forall ((x!84 Int)) (=> (member x!84 (content!5 (left!47 tree!1))) (< x!84 (value!77 tree!1))))) (forall ((x!85 Int)) (=> (member x!85 (content!5 (right!49 tree!1))) (< (value!77 tree!1) x!85))))))

(declare-const tree!2 Tree!17)

(assert (not (=> (isBST!0 tree!2) (or (is-Leaf!16 tree!2) (is-Node!21 tree!2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!19 (Leaf!18) (Node!23 (left!49 Tree!19) (value!79 Int) (right!51 Tree!19)))))

(declare-const tree!1 Tree!19)

(assert (not (or (is-Leaf!18 tree!1) (is-Node!23 tree!1))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!21 (Leaf!20) (Node!25 (left!51 Tree!21) (value!81 Int) (right!53 Tree!21)))))

(declare-const tree!0 Tree!21)

(assert (not (or (is-Leaf!20 tree!0) (is-Node!25 tree!0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!118 (Cons!163 (head!210 (_ BitVec 32)) (tail!216 List!118)) (Nil!163))))

(declare-datatypes () ((AbsQueue!45 (Queue!45 (front!52 List!118) (rear!51 List!118)))))

(define-fun isEmpty!2 ((queue!2 AbsQueue!45)) Bool (ite (and (is-Queue!45 queue!2) (is-Nil!163 (front!52 queue!2)) (is-Nil!163 (rear!51 queue!2))) true false))

(declare-const queue!8 AbsQueue!45)

(define-fun-rec size!2 ((list!0 List!118)) Int (let ((x$1!6 (ite (is-Nil!163 list!0) 0 (+ 1 (size!2 (tail!216 list!0)))))) (assume (>= x$1!6 0) x$1!6)))

(define-fun-rec content!4 ((l!21 List!118)) (Set (_ BitVec 32)) (ite (is-Nil!163 l!21) (as emptyset (_ BitVec 32)) (union (insert (as emptyset (_ BitVec 32)) (head!210 l!21)) (content!4 (tail!216 l!21)))))

(define-fun-rec concat!0 ((l1!12 List!118) (l2!10 List!118)) List!118 (let ((res!35 (ite (is-Nil!163 l1!12) l2!10 (Cons!163 (head!210 l1!12) (concat!0 (tail!216 l1!12) l2!10))))) (assume (and (= (size!2 res!35) (+ (size!2 l1!12) (size!2 l2!10))) (= (content!4 res!35) (union (content!4 l1!12) (content!4 l2!10)))) res!35)))

(define-fun-rec reverse!1 ((l!22 List!118)) List!118 (let ((x$2!4 (ite (is-Nil!163 l!22) Nil!163 (concat!0 (reverse!1 (tail!216 l!22)) (Cons!163 (head!210 l!22) Nil!163))))) (assume (= (content!4 x$2!4) (content!4 l!22)) x$2!4)))

(define-fun isAmortized!0 ((queue!1 AbsQueue!45)) Bool (>= (size!2 (front!52 queue!1)) (size!2 (rear!51 queue!1))))

(define-fun amortizedQueue!0 ((front!3 List!118) (rear!3 List!118)) AbsQueue!45 (let ((x$3!2 (ite (<= (size!2 rear!3) (size!2 front!3)) (Queue!45 front!3 rear!3) (Queue!45 (concat!0 front!3 (reverse!1 rear!3)) Nil!163)))) (assume (isAmortized!0 x$3!2) x$3!2)))

(define-fun enqueue!0 ((queue!3 AbsQueue!45) (elem!1 (_ BitVec 32))) AbsQueue!45 (let ((x$4!1 (amortizedQueue!0 (front!52 queue!3) (Cons!163 elem!1 (rear!51 queue!3))))) (assume (isAmortized!0 x$4!1) x$4!1)))

(declare-const e1!0 (_ BitVec 32))

(declare-const e2!0 (_ BitVec 32))

(declare-const e3!0 (_ BitVec 32))

(define-fun front!5 ((queue!5 AbsQueue!45)) (_ BitVec 32) (head!210 (front!52 queue!5)))

(define-fun tail!8 ((queue!4 AbsQueue!45)) AbsQueue!45 (assume (and (isAmortized!0 queue!4) (not (isEmpty!2 queue!4))) (let ((x$5!1 (amortizedQueue!0 (tail!216 (front!52 queue!4)) (rear!51 queue!4)))) (assume (isAmortized!0 x$5!1) x$5!1))))

(assert (not (ite (isEmpty!2 queue!8) (let ((q1!0 (enqueue!0 queue!8 e1!0))) (let ((q2!0 (enqueue!0 q1!0 e2!0))) (let ((q3!0 (enqueue!0 q2!0 e3!0))) (let ((e1prime!0 (front!5 q3!0))) (let ((q4!0 (tail!8 q3!0))) (let ((e2prime!0 (front!5 q4!0))) (let ((q5!0 (tail!8 q4!0))) (let ((e3prime!0 (front!5 q5!0))) (and (and (= e1!0 e1prime!0) (= e2!0 e2prime!0)) (= e3!0 e3prime!0)))))))))) true)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!138 (fun2!139 (f!637 (=> A1!271 A2!189 R!294)) (pre!455 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!138 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!138 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!138 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!637 f!31) (@ (f!637 f!31) x!76 y!8) z!9) (@ (f!637 f!31) x!76 (@ (f!637 f!31) y!8 z!9)))))))

(declare-datatypes (A0!12 A1!402) ((tuple2!16 (tuple2!17 (_1!8 A0!12) (_2!8 A1!402)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!16 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!16 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!637 (fun2!139 (pre!455 (as f1!0 (fun2!138 A!41 A!41 A!41))) (lambda ((x!1314 A!41) (x!1315 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!637 (fun2!139 (pre!455 (as f2!1 (fun2!138 B!30 B!30 B!30))) (lambda ((x!1316 B!30) (x!1317 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!138 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!138 B!30 B!30 B!30))) (@ (f!637 (fun2!139 (pre!455 (as f1!0 (fun2!138 A!41 A!41 A!41))) (lambda ((x!1318 A!41) (x!1319 A!41)) true))) (_1!8 (as p1!0 (tuple2!16 A!41 B!30))) (_1!8 (as p2!0 (tuple2!16 A!41 B!30))))) (@ (f!637 (fun2!139 (pre!455 (fun2!139 (pre!455 (as f2!1 (fun2!138 B!30 B!30 B!30))) (lambda ((x!1320 B!30) (x!1321 B!30)) true))) (lambda ((x!1322 B!30) (x!1323 B!30)) true))) (_2!8 (as p1!0 (tuple2!16 A!41 B!30))) (_2!8 (as p2!0 (tuple2!16 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!23 (Leaf!22) (Node!27 (left!53 Tree!23) (value!83 Int) (right!55 Tree!23)))))

(declare-const tree!3 Tree!23)

(define-fun-rec content!6 ((thiss!116 Tree!23)) (Set Int) (ite (is-Leaf!22 thiss!116) (as emptyset Int) (union (union (content!6 (left!53 thiss!116)) (insert (as emptyset Int) (value!83 thiss!116))) (content!6 (right!55 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!23)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!53 thiss!117))) (< x!86 (value!83 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!55 thiss!117))) (< (value!83 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!23 (ite (is-Node!27 thiss!115) (inv!9 (assume (is-Node!27 thiss!115) thiss!115)) true))

(assert (not (or (is-Leaf!22 tree!3) (is-Node!27 tree!3))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!25 (Leaf!24) (Node!29 (left!55 Tree!25) (value!85 Int) (right!57 Tree!25)))))

(declare-const tree!3 Tree!25)

(define-fun-rec content!6 ((thiss!116 Tree!25)) (Set Int) (ite (is-Leaf!24 thiss!116) (as emptyset Int) (union (union (content!6 (left!55 thiss!116)) (insert (as emptyset Int) (value!85 thiss!116))) (content!6 (right!57 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!25)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!55 thiss!117))) (< x!86 (value!85 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!57 thiss!117))) (< (value!85 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!25)) Bool (ite (is-Node!29 thiss!115) (inv!9 (assume (is-Node!29 thiss!115) thiss!115)) true))

(declare-const value!4 Int)

(datatype-invariant thiss!115 Tree!25 (ite (is-Node!29 thiss!115) (inv!9 (assume (is-Node!29 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!24 tree!3) (inv!41 (Node!29 Leaf!24 value!4 Leaf!24)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!144 (fun2!145 (f!642 (=> A1!271 A2!189 R!294)) (pre!458 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!144 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!144 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!144 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!642 f!31) (@ (f!642 f!31) x!76 y!8) z!9) (@ (f!642 f!31) x!76 (@ (f!642 f!31) y!8 z!9)))))))

(declare-datatypes (A0!15 A1!407) ((tuple2!20 (tuple2!21 (_1!10 A0!15) (_2!10 A1!407)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!20 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!20 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1367 A!41) (x!1368 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!642 (fun2!145 (pre!458 (as f2!1 (fun2!144 B!30 B!30 B!30))) (lambda ((x!1372 B!30) (x!1373 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!144 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!144 B!30 B!30 B!30))) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1374 A!41) (x!1375 A!41)) true))) (_1!10 (as p1!0 (tuple2!20 A!41 B!30))) (_1!10 (as p2!0 (tuple2!20 A!41 B!30)))) (@ (f!642 (fun2!145 (pre!458 (as f2!1 (fun2!144 B!30 B!30 B!30))) (lambda ((x!1376 B!30) (x!1377 B!30)) true))) (_2!10 (as p1!0 (tuple2!20 A!41 B!30))) (_2!10 (as p2!0 (tuple2!20 A!41 B!30))))) (@ (f!642 (fun2!145 (pre!458 (as f1!0 (fun2!144 A!41 A!41 A!41))) (lambda ((x!1378 A!41) (x!1379 A!41)) true))) (_1!10 (as p1!0 (tuple2!20 A!41 B!30))) (_1!10 (as p2!0 (tuple2!20 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!150 (fun2!151 (f!647 (=> A1!271 A2!189 R!294)) (pre!461 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!41) (f1!0 (fun2!150 A!41 A!41 A!41))))

(declare-const (par (B!30) (f2!1 (fun2!150 B!30 B!30 B!30))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!150 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!647 f!31) (@ (f!647 f!31) x!76 y!8) z!9) (@ (f!647 f!31) x!76 (@ (f!647 f!31) y!8 z!9)))))))

(declare-datatypes (A0!18 A1!412) ((tuple2!24 (tuple2!25 (_1!12 A0!18) (_2!12 A1!412)))))

(declare-const (par (A!41 B!30) (p1!0 (tuple2!24 A!41 B!30))))

(declare-const (par (A!41 B!30) (p2!0 (tuple2!24 A!41 B!30))))

(assert (par (A!41 B!30) (not (=> (and (forall ((x!651 A!41)(x!652 A!41)) (@ (f!647 (fun2!151 (pre!461 (as f1!0 (fun2!150 A!41 A!41 A!41))) (lambda ((x!1411 A!41) (x!1412 A!41)) true))) x!651 x!652)) (forall ((x!653 B!30)(x!654 B!30)) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1413 B!30) (x!1414 B!30)) true))) x!653 x!654)) (isAssociative!0 (as f1!0 (fun2!150 A!41 A!41 A!41))) (isAssociative!0 (as f2!1 (fun2!150 B!30 B!30 B!30))) (@ (f!647 (fun2!151 (pre!461 (as f1!0 (fun2!150 A!41 A!41 A!41))) (lambda ((x!1415 A!41) (x!1416 A!41)) true))) (_1!12 (as p1!0 (tuple2!24 A!41 B!30))) (_1!12 (as p2!0 (tuple2!24 A!41 B!30)))) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1417 B!30) (x!1418 B!30)) true))) (_2!12 (as p1!0 (tuple2!24 A!41 B!30))) (_2!12 (as p2!0 (tuple2!24 A!41 B!30))))) (@ (f!647 (fun2!151 (pre!461 (as f2!1 (fun2!150 B!30 B!30 B!30))) (lambda ((x!1419 B!30) (x!1420 B!30)) true))) (_2!12 (as p1!0 (tuple2!24 A!41 B!30))) (_2!12 (as p2!0 (tuple2!24 A!41 B!30))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!157 (fun2!158 (f!663 (=> A1!271 A2!189 R!294)) (pre!475 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!157 A!42 A!42 A!42))))

(assert (par (A!42) (not (=> (forall ((x!647 A!42)(x!648 A!42)) (@ (f!663 (fun2!158 (pre!475 (as f!34 (fun2!157 A!42 A!42 A!42))) (lambda ((x!1452 A!42) (x!1453 A!42)) true))) x!647 x!648)) (forall ((x!645 A!42)(x!646 A!42)) (@ (f!663 (fun2!158 (pre!475 (as f!34 (fun2!157 A!42 A!42 A!42))) (lambda ((x!1454 A!42) (x!1455 A!42)) true))) x!645 x!646))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!94 (_ BitVec 32))

(declare-const y!14 (_ BitVec 32))

(assert (not (let ((res!489 (bvxor (bvxor x!94 y!14) x!94))) (= res!489 y!14))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!27 (Leaf!26) (Node!31 (left!57 Tree!27) (value!88 Int) (right!59 Tree!27)))))

(declare-const tree!3 Tree!27)

(define-fun-rec content!6 ((thiss!116 Tree!27)) (Set Int) (ite (is-Leaf!26 thiss!116) (as emptyset Int) (union (union (content!6 (left!57 thiss!116)) (insert (as emptyset Int) (value!88 thiss!116))) (content!6 (right!59 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!27)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!57 thiss!117))) (< x!86 (value!88 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!59 thiss!117))) (< (value!88 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!27)) Bool (ite (is-Node!31 thiss!115) (inv!9 (assume (is-Node!31 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!27 (ite (is-Node!31 thiss!115) (inv!9 (assume (is-Node!31 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!26 tree!3) (inv!41 Leaf!26))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!161 (fun2!162 (f!665 (=> A1!271 A2!189 R!294)) (pre!477 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!161 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!161 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!665 f!32) x!77 y!9) (@ (f!665 f!32) y!9 x!77))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!665 (fun2!162 (pre!477 (as f!34 (fun2!161 A!42 A!42 A!42))) (lambda ((x!1473 A!42) (x!1474 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!161 A!42 A!42 A!42)))) (forall ((x!655 A!42)(x!656 A!42)) (@ (f!665 (fun2!162 (pre!477 (as f!34 (fun2!161 A!42 A!42 A!42))) (lambda ((x!1475 A!42) (x!1476 A!42)) true))) x!655 x!656))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!29 (Leaf!28) (Node!33 (left!59 Tree!29) (value!90 Int) (right!61 Tree!29)))))

(declare-const tree!3 Tree!29)

(define-fun-rec content!6 ((thiss!116 Tree!29)) (Set Int) (ite (is-Leaf!28 thiss!116) (as emptyset Int) (union (union (content!6 (left!59 thiss!116)) (insert (as emptyset Int) (value!90 thiss!116))) (content!6 (right!61 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!29)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!59 thiss!117))) (< x!86 (value!90 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!61 thiss!117))) (< (value!90 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!29)) Bool (ite (is-Node!33 thiss!115) (inv!9 (assume (is-Node!33 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!29 (ite (is-Node!33 thiss!115) (inv!9 (assume (is-Node!33 thiss!115) thiss!115)) true))

(assert (not (=> (is-Leaf!28 tree!3) (inv!41 Leaf!28))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!89 (_ BitVec 32))

(assert (not (let ((res!483 (= (bvand x!89 #b00000000000000000000000000000001) #b00000000000000000000000000000000))) (= res!483 (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem x!89 #b00000000000000000000000000000010)) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!31 (Leaf!30) (Node!35 (left!61 Tree!31) (value!92 Int) (right!63 Tree!31)))))

(declare-const tree!3 Tree!31)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!31)) (Set Int) (ite (is-Leaf!30 thiss!116) (as emptyset Int) (union (union (content!6 (left!61 thiss!116)) (insert (as emptyset Int) (value!92 thiss!116))) (content!6 (right!63 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!31)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!61 thiss!117))) (< x!86 (value!92 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!63 thiss!117))) (< (value!92 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!31)) Bool (ite (is-Node!35 thiss!115) (inv!9 (assume (is-Node!35 thiss!115) thiss!115)) true))

(define-fun-rec insert!1 ((tree!3 Tree!31) (value!4 Int)) Tree!31 (let ((res!61 (ite (is-Leaf!30 tree!3) (Node!35 Leaf!30 value!4 Leaf!30) (ite (< (value!92 tree!3) value!4) (Node!35 (left!61 tree!3) (value!92 tree!3) (insert!1 (right!63 tree!3) value!4)) (ite (> (value!92 tree!3) value!4) (Node!35 (insert!1 (left!61 tree!3) value!4) (value!92 tree!3) (right!63 tree!3)) (Node!35 (left!61 tree!3) (value!92 tree!3) (right!63 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(datatype-invariant thiss!115 Tree!31 (ite (is-Node!35 thiss!115) (inv!9 (assume (is-Node!35 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!30 tree!3)) (is-Node!35 tree!3)) (let ((l!31 (left!61 tree!3))) (let ((v!16 (value!92 tree!3))) (let ((r!12 (right!63 tree!3))) (=> (< v!16 value!4) (inv!41 (Node!35 l!31 v!16 (insert!1 r!12 value!4))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!165 (fun2!166 (f!668 (=> A1!271 A2!189 R!294)) (pre!479 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!165 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!165 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!668 f!32) x!77 y!9) (@ (f!668 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!165 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!668 f!33) (@ (f!668 f!33) x!78 y!10) z!10) (@ (f!668 f!33) (@ (f!668 f!33) y!10 z!10) x!78))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!668 (fun2!166 (pre!479 (as f!34 (fun2!165 A!42 A!42 A!42))) (lambda ((x!1498 A!42) (x!1499 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!165 A!42 A!42 A!42))) (isRotate!0 (as f!34 (fun2!165 A!42 A!42 A!42)))) (forall ((x!649 A!42)(x!650 A!42)) (@ (f!668 (fun2!166 (pre!479 (as f!34 (fun2!165 A!42 A!42 A!42))) (lambda ((x!1500 A!42) (x!1501 A!42)) true))) x!649 x!650))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!90 (_ BitVec 32))

(assert (not (let ((b!959 (= (bvlshr x!90 #b00000000000000000000000000011111) #b00000000000000000000000000000001))) (= b!959 (bvslt x!90 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (or (and (bvsge x!101 #b00000000000000000000000000000000) (bvsle y!17 #b00000000000000000000000000000000)) (and (bvsle x!101 #b00000000000000000000000000000000) (bvsge y!17 #b00000000000000000000000000000000))) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!169 (fun2!170 (f!672 (=> A1!271 A2!189 R!294)) (pre!481 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!169 A!42 A!42 A!42))))

(define-fun (par (A!39) (isCommutative!0 ((f!32 (fun2!169 A!39 A!39 A!39))) Bool (forall ((x!77 A!39)(y!9 A!39)) (= (@ (f!672 f!32) x!77 y!9) (@ (f!672 f!32) y!9 x!77))))))

(define-fun (par (A!40) (isRotate!0 ((f!33 (fun2!169 A!40 A!40 A!40))) Bool (forall ((x!78 A!40)(y!10 A!40) (z!10 A!40)) (= (@ (f!672 f!33) (@ (f!672 f!33) x!78 y!10) z!10) (@ (f!672 f!33) (@ (f!672 f!33) y!10 z!10) x!78))))))

(define-fun (par (A!38) (isAssociative!0 ((f!31 (fun2!169 A!38 A!38 A!38))) Bool (forall ((x!76 A!38)(y!8 A!38) (z!9 A!38)) (= (@ (f!672 f!31) (@ (f!672 f!31) x!76 y!8) z!9) (@ (f!672 f!31) x!76 (@ (f!672 f!31) y!8 z!9)))))))

(assert (par (A!42) (not (=> (and (forall ((x!647 A!42)(x!648 A!42)) (@ (f!672 (fun2!170 (pre!481 (as f!34 (fun2!169 A!42 A!42 A!42))) (lambda ((x!1537 A!42) (x!1538 A!42)) true))) x!647 x!648)) (isCommutative!0 (as f!34 (fun2!169 A!42 A!42 A!42))) (isRotate!0 (as f!34 (fun2!169 A!42 A!42 A!42)))) (isAssociative!0 (as f!34 (fun2!169 A!42 A!42 A!42)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const y!17 (_ BitVec 32))

(declare-const x!101 (_ BitVec 32))

(assert (not (=> (and (bvsgt y!17 #b00000000000000000000000000000000) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (bvsge x!101 #b00000000000000000000000000000000) (bvsle x!101 y!17)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const y!17 (_ BitVec 32))

(declare-const x!101 (_ BitVec 32))

(assert (not (=> (and (bvsgt y!17 #b00000000000000000000000000000000) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (bvsgt x!101 y!17) (bvsge x!101 #b00000000000000000000000000000000) (bvsle y!17 x!101)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (and (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 #b00000000000000000000000000000000)) (bvslt y!17 #b00000000000000000000000000000000) (bvslt x!101 #b00000000000000000000000000000000) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 x!101)) (bvsle x!101 #b00000000000000000000000000000000) (bvsle x!101 y!17)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!101 (_ BitVec 32))

(declare-const y!17 (_ BitVec 32))

(assert (not (=> (and (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 #b00000000000000000000000000000000)) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvslt y!17 #b00000000000000000000000000000000)) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt x!101 y!17)) (or (bvslt x!101 #b00000000000000000000000000000000) (bvsgt y!17 x!101)) (or (bvsgt x!101 #b00000000000000000000000000000000) (bvsgt x!101 y!17))) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (and (bvsge #b00000000000000000000000000000101 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000101 #b00000000000000000000000000100000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!33 (Leaf!32) (Node!37 (left!63 Tree!33) (value!94 Int) (right!65 Tree!33)))))

(declare-const tree!3 Tree!33)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!33)) (Set Int) (ite (is-Leaf!32 thiss!116) (as emptyset Int) (union (union (content!6 (left!63 thiss!116)) (insert (as emptyset Int) (value!94 thiss!116))) (content!6 (right!65 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!33)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!63 thiss!117))) (< x!86 (value!94 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!65 thiss!117))) (< (value!94 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!33)) Bool (ite (is-Node!37 thiss!115) (inv!9 (assume (is-Node!37 thiss!115) thiss!115)) true))

(define-fun-rec insert!1 ((tree!3 Tree!33) (value!4 Int)) Tree!33 (let ((res!61 (ite (is-Leaf!32 tree!3) (Node!37 Leaf!32 value!4 Leaf!32) (ite (< (value!94 tree!3) value!4) (Node!37 (left!63 tree!3) (value!94 tree!3) (insert!1 (right!65 tree!3) value!4)) (ite (> (value!94 tree!3) value!4) (Node!37 (insert!1 (left!63 tree!3) value!4) (value!94 tree!3) (right!65 tree!3)) (Node!37 (left!63 tree!3) (value!94 tree!3) (right!65 tree!3))))))) (assume (= (content!6 res!61) (union (content!6 tree!3) (insert (as emptyset Int) value!4))) res!61)))

(datatype-invariant thiss!115 Tree!33 (ite (is-Node!37 thiss!115) (inv!9 (assume (is-Node!37 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!32 tree!3)) (is-Node!37 tree!3)) (let ((l!31 (left!63 tree!3))) (let ((v!16 (value!94 tree!3))) (let ((r!12 (right!65 tree!3))) (=> (and (>= v!16 value!4) (> v!16 value!4)) (inv!41 (Node!37 (insert!1 l!31 value!4) v!16 r!12)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (let ((x$2!38 (isBitNSet!0 #b11111111111111111111111111011111 #b00000000000000000000000000000101))) (= x$2!38 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(define-fun rightPropagateRightmostOne!0 ((x!97 (_ BitVec 32))) (_ BitVec 32) (bvor x!97 (bvsub x!97 #b00000000000000000000000000000001)))

(declare-const x!98 (_ BitVec 32))

(assert (not (let ((y!15 (rightPropagateRightmostOne!0 x!98))) (= y!15 (rightPropagateRightmostOne!0 y!15)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const indexFromLeft!0 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000)) (and (bvsge (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000000000) (bvslt (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!173 (fun2!174 (f!677 (=> A1!271 A2!189 R!294)) (pre!483 (=> A1!271 A2!189 Bool))))))

(declare-const (par (A!42) (f!34 (fun2!173 A!42 A!42 A!42))))

(declare-const (par (A!42) (x!647 A!42)))

(declare-const (par (A!42) (x!648 A!42)))

(assert (par (A!42) (not (@ (f!677 (fun2!174 (pre!483 (fun2!174 (pre!483 (as f!34 (fun2!173 A!42 A!42 A!42))) (lambda ((x!1579 A!42) (x!1580 A!42)) true))) (lambda ((x!1581 A!42) (x!1582 A!42)) true))) (as x!647 A!42) (as x!648 A!42)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const indexFromLeft!0 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!95 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000) (bitAt!0 x!95 (bvsub #b00000000000000000000000000011111 indexFromLeft!0))) (and (bvsge (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000000000) (bvslt (bvsub #b00000000000000000000000000011111 indexFromLeft!0) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!271 A2!189 R!294) ((fun2!177 (fun2!178 (f!679 (=> A1!271 A2!189 R!294)) (pre!485 (=> A1!271 A2!189 Bool))))))

(declare-const f!35 (fun2!177 Int Int Int))

(assert (not (=> (forall ((x!657 Int)(x!658 Int)) (@ (f!679 (fun2!178 (pre!485 f!35) (lambda ((x!1595 Int) (x!1596 Int)) true))) x!657 x!658)) (forall ((x!645 Int)(x!646 Int)) (@ (f!679 (fun2!178 (pre!485 f!35) (lambda ((x!1597 Int) (x!1598 Int)) true))) x!645 x!646)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const indexFromLeft!0 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!95 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 indexFromLeft!0) (bvslt indexFromLeft!0 #b00000000000000000000000000100000) (not (bitAt!0 x!95 (bvsub #b00000000000000000000000000011111 indexFromLeft!0))) (not (= indexFromLeft!0 #b00000000000000000000000000000000))) (and (bvsle #b00000000000000000000000000000000 (bvsub indexFromLeft!0 #b00000000000000000000000000000001)) (bvslt (bvsub indexFromLeft!0 #b00000000000000000000000000000001) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!8 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!35 (Leaf!34) (Node!39 (left!65 Tree!35) (value!96 Int) (right!67 Tree!35)))))

(declare-const tree!3 Tree!35)

(declare-const value!4 Int)

(define-fun-rec content!6 ((thiss!116 Tree!35)) (Set Int) (ite (is-Leaf!34 thiss!116) (as emptyset Int) (union (union (content!6 (left!65 thiss!116)) (insert (as emptyset Int) (value!96 thiss!116))) (content!6 (right!67 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!35)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!65 thiss!117))) (< x!86 (value!96 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!67 thiss!117))) (< (value!96 thiss!117) x!87)))))

(define-fun inv!41 ((thiss!115 Tree!35)) Bool (ite (is-Node!39 thiss!115) (inv!9 (assume (is-Node!39 thiss!115) thiss!115)) true))

(datatype-invariant thiss!115 Tree!35 (ite (is-Node!39 thiss!115) (inv!9 (assume (is-Node!39 thiss!115) thiss!115)) true))

(assert (not (=> (and (not (is-Leaf!34 tree!3)) (is-Node!39 tree!3)) (let ((l!31 (left!65 tree!3))) (let ((v!16 (value!96 tree!3))) (let ((r!12 (right!67 tree!3))) (=> (and (>= v!16 value!4) (<= v!16 value!4)) (inv!41 (Node!39 l!31 v!16 r!12)))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!37 (Leaf!36) (Node!41 (left!67 Tree!37) (value!98 Int) (right!69 Tree!37)))))

(declare-const thiss!115 Tree!37)

(define-fun-rec content!6 ((thiss!116 Tree!37)) (Set Int) (ite (is-Leaf!36 thiss!116) (as emptyset Int) (union (union (content!6 (left!67 thiss!116)) (insert (as emptyset Int) (value!98 thiss!116))) (content!6 (right!69 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!37)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!67 thiss!117))) (< x!86 (value!98 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!69 thiss!117))) (< (value!98 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!37 (ite (is-Node!41 thiss!115) (inv!9 (assume (is-Node!41 thiss!115) thiss!115)) true))

(assert (not (=> (is-Node!41 thiss!115) (is-Node!41 thiss!115))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!8 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(declare-const x!93 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000) (not (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000))) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((Tree!39 (Leaf!38) (Node!43 (left!69 Tree!39) (value!101 Int) (right!71 Tree!39)))))

(declare-const thiss!116 Tree!39)

(define-fun-rec content!6 ((thiss!116 Tree!39)) (Set Int) (ite (is-Leaf!38 thiss!116) (as emptyset Int) (union (union (content!6 (left!69 thiss!116)) (insert (as emptyset Int) (value!101 thiss!116))) (content!6 (right!71 thiss!116)))))

(define-fun inv!9 ((thiss!117 Tree!39)) Bool (and (forall ((x!86 Int)) (=> (member x!86 (content!6 (left!69 thiss!117))) (< x!86 (value!101 thiss!117)))) (forall ((x!87 Int)) (=> (member x!87 (content!6 (right!71 thiss!117))) (< (value!101 thiss!117) x!87)))))

(datatype-invariant thiss!115 Tree!39 (ite (is-Node!43 thiss!115) (inv!9 (assume (is-Node!43 thiss!115) thiss!115)) true))

(assert (not (or (is-Leaf!38 thiss!116) (is-Node!43 thiss!116))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!25 Bool)

(declare-const d!2 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (let ((t!124 (ite b!25 d!2 false))) (let ((r!13 t!124)) (let ((res!66 (assume (= x!1594 #b00000000000000000000000000000010) r!13))) (=> (= res!66 (and b!25 d!2)) (or (= (bvand (toInt!0 b!25) (toInt!0 d!2)) #b00000000000000000000000000000000) (= (bvand (toInt!0 b!25) (toInt!0 d!2)) #b00000000000000000000000000000001)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!8 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(declare-const x!93 (_ BitVec 32))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000) (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000)) (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= #b00000000000000000000000000001010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= 10 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!8 (_ BitVec 32))

(declare-const x!93 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (=> (and (bvsge n!8 #b00000000000000000000000000000000) (bvslt n!8 #b00000000000000000000000000100000)) (let ((res!487 (bvxor x!93 (bvshl #b00000000000000000000000000000001 n!8)))) (ite (not (= (isBitNSet!0 x!93 n!8) #b00000000000000000000000000000000)) (= (isBitNSet!0 res!487 n!8) #b00000000000000000000000000000000) (not (= (isBitNSet!0 res!487 n!8) #b00000000000000000000000000000000)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (= x!1601 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!26 Bool)

(declare-const d!3 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (let ((t!125 (ite b!26 true d!3))) (let ((r!14 t!125)) (let ((res!537 (assume (= x!1601 #b00000000000000000000000000000010) r!14))) (and (= res!537 (or b!26 d!3)) (= res!537 (toBool!0 (bvor (toInt!0 b!26) (toInt!0 d!3)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (= x!1594 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const y!19 (_ BitVec 32))

(assert (not (=> (not (= y!19 #b00000000000000000000000000000000)) (not (= y!19 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!25 Bool)

(declare-const d!2 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1592 #b00000000000000000000000000000000)) (let ((x!1593 (bvadd x!1592 #b00000000000000000000000000000001))) (let ((x!1594 (bvmul x!1593 #b00000000000000000000000000000010))) (let ((t!124 (ite b!25 d!2 false))) (let ((r!13 t!124)) (let ((res!536 (assume (= x!1594 #b00000000000000000000000000000010) r!13))) (and (= res!536 (and b!25 d!2)) (= res!536 (toBool!0 (bvand (toInt!0 b!25) (toInt!0 d!2)))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (and (bvsge i!23 #b00000000000000000000000000000000) (bvslt i!23 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (and (bvsge (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)) #b00000000000000000000000000000000) (bvslt (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)) #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!27 Bool)

(declare-const d!4 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (let ((r!15 (not (= b!27 d!4)))) (let ((res!68 (assume (= x!1591 #b00000000000000000000000000000010) r!15))) (=> (= res!68 (not (= b!27 d!4))) (or (= (bvxor (toInt!0 b!27) (toInt!0 d!4)) #b00000000000000000000000000000000) (= (bvxor (toInt!0 b!27) (toInt!0 d!4)) #b00000000000000000000000000000001))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(define-fun bitAt!0 ((x!88 (_ BitVec 32)) (n!5 (_ BitVec 32))) Bool (= (bvand (bvashr x!88 n!5) #b00000000000000000000000000000001) #b00000000000000000000000000000001))

(declare-const x!99 (_ BitVec 32))

(declare-const y!16 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (let ((isOk!0 (= (bitAt!0 x!99 i!23) (bitAt!0 y!16 (assume (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)) (bvsrem (bvadd i!23 n!9) #b00000000000000000000000000100000)))))) (=> (and (not (= i!23 #b00000000000000000000000000000000)) isOk!0) (and (and (and (bvsle #b00000000000000000000000000000000 (bvsub i!23 #b00000000000000000000000000000001)) (bvslt (bvsub i!23 #b00000000000000000000000000000001) #b00000000000000000000000000100000)) (bvsle #b00000000000000000000000000000000 n!9)) (bvslt n!9 #b00000000000000000000000000100000)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!26 Bool)

(declare-const d!3 Bool)

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1599 #b00000000000000000000000000000000)) (let ((x!1600 (bvadd x!1599 #b00000000000000000000000000000001))) (let ((x!1601 (bvmul x!1600 #b00000000000000000000000000000010))) (let ((t!125 (ite b!26 true d!3))) (let ((r!14 t!125)) (let ((res!67 (assume (= x!1601 #b00000000000000000000000000000010) r!14))) (=> (= res!67 (or b!26 d!3)) (or (= (bvor (toInt!0 b!26) (toInt!0 d!3)) #b00000000000000000000000000000000) (= (bvor (toInt!0 b!26) (toInt!0 d!3)) #b00000000000000000000000000000001)))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!23 (_ BitVec 32))

(declare-const n!9 (_ BitVec 32))

(assert (not (=> (and (bvsle #b00000000000000000000000000000000 i!23) (bvslt i!23 #b00000000000000000000000000100000) (bvsle #b00000000000000000000000000000000 n!9) (bvslt n!9 #b00000000000000000000000000100000)) (not (= #b00000000000000000000000000100000 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!32 (_ BitVec 8))

(declare-const c!15 (_ BitVec 8))

(assert (not (let ((res!570 (bvadd ((_ sign_extend 24) b!32) ((_ sign_extend 24) c!15)))) (and (bvsle #b11111111111111111111111100000000 res!570) (bvsle res!570 #b00000000000000000000000011111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!7 (_ BitVec 32))

(assert (not (=> (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)) (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (= x!1591 #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!24 (_ BitVec 32))

(assert (not (bvslt ((_ sign_extend 24) ((_ extract 7 0) i!24)) #b00000000000000000000000010000000)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not true))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!27 Bool)

(declare-const d!4 Bool)

(define-fun toBool!0 ((x!106 (_ BitVec 32))) Bool (= x!106 #b00000000000000000000000000000001))

(define-fun toInt!0 ((b!28 Bool)) (_ BitVec 32) (ite b!28 #b00000000000000000000000000000001 #b00000000000000000000000000000000))

(assert (not (let ((x!1589 #b00000000000000000000000000000000)) (let ((x!1590 (bvadd x!1589 #b00000000000000000000000000000001))) (let ((x!1591 (bvmul x!1590 #b00000000000000000000000000000010))) (let ((r!15 (not (= b!27 d!4)))) (let ((res!538 (assume (= x!1591 #b00000000000000000000000000000010) r!15))) (and (= res!538 (not (= b!27 d!4))) (= res!538 (toBool!0 (bvxor (toInt!0 b!27) (toInt!0 d!4))))))))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const n!7 (_ BitVec 32))

(declare-const x!92 (_ BitVec 32))

(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (=> (and (bvsge n!7 #b00000000000000000000000000000000) (bvslt n!7 #b00000000000000000000000000100000)) (let ((res!485 (bvor x!92 (bvshl #b00000000000000000000000000000001 n!7)))) (not (= (isBitNSet!0 res!485 n!7) #b00000000000000000000000000000000))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (= (bvneg (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv x!110 #b00000000000000000000000000000010))) (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv (bvneg x!110) #b00000000000000000000000000000010))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!31 (_ BitVec 8))

(assert (not (=> (and (bvsge ((_ sign_extend 24) b!31) #b11111111111111111111111110000000) (bvsle ((_ sign_extend 24) b!31) #b00000000000000000000000001111111)) (bvslt ((_ sign_extend 24) b!31) #b00000000000000000000000010000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (and (bvsge #b00000000000000000000000000000011 #b00000000000000000000000000000000) (bvslt #b00000000000000000000000000000011 #b00000000000000000000000000100000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const b!31 (_ BitVec 8))

(assert (not (and (bvsge ((_ sign_extend 24) b!31) #b11111111111111111111111110000000) (bvsle ((_ sign_extend 24) b!31) #b00000000000000000000000001111111))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(define-fun isBitNSet!0 ((x!91 (_ BitVec 32)) (n!6 (_ BitVec 32))) (_ BitVec 32) (bvand x!91 (bvshl #b00000000000000000000000000000001 n!6)))

(assert (not (let ((x$1!84 (isBitNSet!0 #b00000000000000000000000001111010 #b00000000000000000000000000000011))) (not (= x$1!84 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (let ((b!29 #b01111111)) (not (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem ((_ sign_extend 24) b!29) #b00000000000000000000000000000010)) #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!110 (_ BitVec 32))

(assert (not (=> (not (= x!110 #b10000000000000000000000000000000)) (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(define-fun test!6 ((b!30 (_ BitVec 8))) (_ BitVec 32) (ite (bvsgt ((_ sign_extend 24) b!30) #b00000000000000000000000000000000) #b00000000000000000000000000000000 #b00000000000000000000000000000001))

(assert (not (let ((b!29 #b01111111)) (= (test!6 b!29) #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!111 (_ BitVec 32))

(assert (not (= (bvneg (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsdiv x!111 #b00000000000000000000000000000010))) (assume (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000)) (bvsdiv x!111 #b11111111111111111111111111111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (R!501) ((fun0!36 (fun0!37 (f!758 (=> R!501)) (pre!564 (=> Bool))))))

(assert (not (and (@ (f!758 (fun0!37 (pre!564 (fun0!37 (lambda () #b00000000000000000000000000000001) (lambda () true))) (lambda () true)))) (@ (f!758 (fun0!37 (pre!564 (fun0!37 (lambda () #b00000000000000000000000000000010) (lambda () true))) (lambda () true)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!374 (B!166 (size!176 (_ BitVec 32))) (C!21))))

(declare-const a!35 A!374)

(assert (not (or (is-C!21 a!35) (is-B!166 a!35))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!115 Int)

(assert (not (let ((x$1!86 (choose y!20 Int (let ((z!11 (+ x!115 2))) (= z!11 y!20))))) (= x$1!86 (+ x!115 2)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(assert (not (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (A1!517 R!537) ((fun1!213 (fun1!214 (f!792 (=> A1!517 R!537)) (pre!598 (=> A1!517 Bool))))))

(declare-datatypes (T!0) ((List!121 (Cons!179 (h!79 T!0) (t!127 (List!121 T!0))) (Nil!179))))

(declare-datatypes () ((Client!2 (Client!3 (f!794 (fun1!213 (_ BitVec 32) (List!121 (_ BitVec 32))))))))

(declare-const thiss!156 Client!2)

(declare-const x!1646 (_ BitVec 32))

(datatype-invariant thiss!156 Client!2 (forall ((x!1646 (_ BitVec 32))) (@ (f!792 (fun1!214 (pre!598 (f!794 thiss!156)) (lambda ((x!1650 (_ BitVec 32))) true))) x!1646)))

(assert (not (@ (f!792 (fun1!214 (pre!598 (fun1!214 (pre!598 (f!794 thiss!156)) (lambda ((x!1652 (_ BitVec 32))) true))) (lambda ((x!1653 (_ BitVec 32))) true))) x!1646)))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((List!122 (Cons!180 (head!225 (_ BitVec 32)) (tail!231 List!122)) (Nil!180))))

(declare-const l!33 List!122)

(assert (not (or (is-Nil!180 l!33) (is-Cons!180 l!33))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes () ((A!382 (B!168 (size!181 (_ BitVec 32))) (C!23))))

(declare-const a!36 A!382)

(assert (not (or (is-C!23 a!36) (is-B!168 a!36))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!115 Int)

(assert (not (exists ((y!20 Int)) (not (not (let ((z!11 (+ x!115 2))) (= z!11 y!20)))))))

(check-sat)


(declare-datatypes (T!0) ((List!125 (Cons!183 (h!81 T!0) (t!129 (List!125 T!0))) (Nil!183))))

(define-fun-rec (par (T!181) (size!0 ((thiss!151 (List!125 T!181))) Int (let ((x$1!0 (ite (is-Nil!183 thiss!151) 0 (+ 1 (size!0 (t!129 thiss!151)))))) (assume (>= x$1!0 0) x$1!0)))))

(declare-datatypes (A1!517 R!537) ((fun1!219 (fun1!220 (f!797 (=> A1!517 R!537)) (pre!601 (=> A1!517 Bool))))))

(declare-datatypes () ((Client!6 (Client!7 (f!799 (fun1!219 (_ BitVec 32) (List!125 (_ BitVec 32))))))))

(define-fun client!0 () Client!6 (Client!7 (fun1!220 (lambda ((x!117 (_ BitVec 32))) (Cons!183 #b00000000000000000000000000000001 (as Nil!183 (List!125 (_ BitVec 32))))) (lambda ((x!1651 (_ BitVec 32))) true))))

(datatype-invariant thiss!156 Client!6 (forall ((x!1646 (_ BitVec 32))) (@ (f!797 (fun1!220 (pre!601 (f!799 thiss!156)) (lambda ((x!1650 (_ BitVec 32))) true))) x!1646)))

(assert (not (not (= (size!0 (@ (f!797 (f!799 client!0)) #b00000000000000000000000000000000)) 0))))

(check-sat)


(declare-datatypes (R!501) ((fun0!41 (fun0!42 (f!800 (=> R!501)) (pre!603 (=> Bool))))))

(define-fun add!0 ((a!34 (fun0!41 (_ BitVec 32))) (b!33 (fun0!41 (_ BitVec 32)))) (_ BitVec 32) (bvadd (@ (f!800 a!34)) (@ (f!800 b!33))))

(assert (not (let ((x$1!85 (add!0 (fun0!42 (lambda () #b00000000000000000000000000000001) (lambda () true)) (fun0!42 (lambda () #b00000000000000000000000000000010) (lambda () true))))) (= x$1!85 #b00000000000000000000000000000011))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const x!112 (_ BitVec 32))

(assert (not (= (assume (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000)) (bvsrem x!112 #b00000000000000000000000000000010)) (assume (not (= #b11111111111111111111111111111110 #b00000000000000000000000000000000)) (bvsrem x!112 #b11111111111111111111111111111110)))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!27 Int)

(assert (not (=> (and (>= i!27 0) (> i!27 0)) (>= (- i!27 1) 0))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-datatypes (R!501) ((fun0!45 (fun0!46 (f!804 (=> R!501)) (pre!605 (=> Bool))))))

(declare-const a!34 (fun0!45 (_ BitVec 32)))

(declare-const b!33 (fun0!45 (_ BitVec 32)))

(assert (not (=> (@ (f!804 (fun0!46 (pre!605 a!34) (lambda () true)))) (@ (f!804 (fun0!46 (pre!605 (fun0!46 (pre!605 b!33) (lambda () true))) (lambda () true)))))))

(check-sat)

; check-assumptions required here, but not part of tip standard
(declare-const i!27 Int)

(declare-datatypes () ((List!128 (Cons!186 (head!227 (_ BitVec 32)) (tail!233 List!128)) (Nil!186))))

(define-fun-rec size!12 ((l!32 List!128)) Int (let ((res!80 (ite (is-Nil!186 l!32) 0 (+ 1 (size!12 (tail!233 l!32)))))) (assume (>= res!80 0) res!80)))

(define-fun-rec createListOfSize!0 ((i!25 Int)) List!128 (assume (>= i!25 0) (let ((x$1!19 (ite (= i!25 0) Nil!186 (Cons!186 #b00000000000000000000000000000000 (createListOfSize!0 (- i!25 1)))))) (assume (= (size!12 x$1!19) i!25) x$1!19))))

(define-fun listOfSize!0 ((i!26 Int)) List!128 (assume (>= i!26 0) (let ((x$2!7 (ite (= i!26 0) Nil!186 (assume (= (size!12 (createListOfSize!0 i!26)) i!26) (choose res!81 List!128 (= (size!12 res!81) i!26)))))) (assume (= (size!12 x$2!7) i!26) x$2!7))))

(assert (not (=> (>= i!27 0) (let ((x$3!17 (ite (> i!27 0) (Cons!186 #b00000000000000000000000000000000 (listOfSize!0 (- i!27 1))) Nil!186))) (= (size!12 x$3!17) i!27)))))


(declare-datatypes (A1!541 R!567) ((fun1!226 (fun1!227 (f!820 (=> A1!541 R!567)) (pre!619 (=> A1!541 Bool))))))

(define-fun addX!0 ((x!118 (_ BitVec 32))) (fun1!226 (_ BitVec 32) (_ BitVec 32)) (fun1!227 (lambda ((a!37 (_ BitVec 32))) (bvadd a!37 x!118)) (lambda ((a!142 (_ BitVec 32))) true)))

(assert (not (let ((add1!0 (addX!0 #b00000000000000000000000000000001))) (let ((add2!0 (addX!0 #b00000000000000000000000000000010))) (= (@ (f!820 add1!0) (@ (f!820 add2!0) #b00000000000000000000000000000001)) #b00000000000000000000000000000100)))))


(declare-datatypes (R!501) ((fun0!50 (fun0!51 (f!822 (=> R!501)) (pre!620 (=> Bool))))))

(declare-const a!34 (fun0!50 (_ BitVec 32)))

(declare-const b!33 (fun0!50 (_ BitVec 32)))


(assert (not (not (= #b00000000000000000000000000000010 #b00000000000000000000000000000000))))

(check-sat)


(declare-datatypes (R!501) ((fun0!52 (fun0!53 (f!824 (=> R!501)) (pre!622 (=> Bool))))))

(declare-const a!34 (fun0!52 (_ BitVec 32)))

(assert (not (@ (f!824 (fun0!53 (pre!622 (fun0!53 (pre!622 a!34) (lambda () true))) (lambda () true))))))