Skip to content

Instantly share code, notes, and snippets.

/gist:16e489ce5c513e8c4bc6

Created June 11, 2015 13:03
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save anonymous/16e489ce5c513e8c4bc6 to your computer and use it in GitHub Desktop.
Save anonymous/16e489ce5c513e8c4bc6 to your computer and use it in GitHub Desktop.
Download ZIP
SMT input file
Raw
gistfile1.txt
(get-info :version)
; Input file is ..\hackathon\examples\doubly-linked-list\sequences-repo-2014-09-18.sil
; Started: 2015-03-10 16:56:58
; Silicon.buildVersion: 0.1-SNAPSHOT 1ac46fcb3bc3 default 2015/03/09 10:54:08
; ------------------------------------------------------------
; Preamble start
;
; ; /z3config.smt2
(set-option :print-success true) ; Boogie: false
(set-option :global-decls true) ; Boogie: default
(set-option :auto_config false) ; Usually a good idea
(set-option :smt.mbqi false)
(set-option :model.v2 true)
(set-option :smt.phase_selection 0)
(set-option :smt.restart_strategy 0)
(set-option :smt.restart_factor |1.5|)
(set-option :smt.arith.random_initial_value true)
(set-option :smt.case_split 3)
(set-option :smt.delay_units true)
(set-option :smt.delay_units_threshold 16)
(set-option :nnf.sk_hack true)
(set-option :smt.qi.eager_threshold 100)
(set-option :smt.qi.cost "(+ weight generation)")
(set-option :type_check true)
(set-option :smt.bv.reflect true)
(set-option :smt.qi.profile true)
(set-option :smt.qi.profile_freq 1000)
(set-option :trace true)
; ; /preamble.smt2
(declare-datatypes () ((
$Snap $Snap.unit
($Snap.combine ($Snap.first $Snap) ($Snap.second $Snap)))))
(declare-sort $Ref)
(declare-const $Ref.null $Ref)
(define-sort $Perm () Real)
(define-const $Perm.Write $Perm 1.0)
(define-const $Perm.No $Perm 0.0)
(define-fun $Perm.isValidVar ((p $Perm)) Bool
(<= $Perm.No p))
(define-fun $Perm.isReadVar ((p $Perm) (ub $Perm)) Bool
(and ($Perm.isValidVar p)
(not (= p $Perm.No))
(< p $Perm.Write)))
(define-fun $Perm.min ((p1 $Perm) (p2 $Perm)) Real
(ite (<= p1 p2) p1 p2))
(define-fun $Math.min ((a Int) (b Int)) Int
(ite (<= a b) a b))
(define-fun $Math.clip ((a Int)) Int
(ite (< a 0) 0 a))
(push) ; 1
(declare-sort $Seq<$Ref>)
(declare-sort $Seq<Int>)
(declare-sort $Set<$Ref>)
(declare-sort $Set<$Seq<$Ref>>)
(declare-sort $Set<Int>)
(declare-sort $FVF<Int>)
(declare-sort $FVF<$Ref>)
(declare-sort $FVF<$Seq<$Ref>>)
; /dafny_axioms/sets_declarations_dafny.smt2 [Ref]
(declare-fun $Set.in ($Ref $Set<$Ref>) Bool)
(declare-fun $Set.card ($Set<$Ref>) Int)
(declare-fun $Set.empty<$Ref> () $Set<$Ref>)
(declare-fun $Set.singleton ($Ref) $Set<$Ref>)
(declare-fun $Set.unionone ($Set<$Ref> $Ref) $Set<$Ref>)
(declare-fun $Set.union ($Set<$Ref> $Set<$Ref>) $Set<$Ref>)
(declare-fun $Set.disjoint ($Set<$Ref> $Set<$Ref>) Bool)
(declare-fun $Set.difference ($Set<$Ref> $Set<$Ref>) $Set<$Ref>)
(declare-fun $Set.intersection ($Set<$Ref> $Set<$Ref>) $Set<$Ref>)
(declare-fun $Set.subset ($Set<$Ref> $Set<$Ref>) Bool)
(declare-fun $Set.equal ($Set<$Ref> $Set<$Ref>) Bool)
; /dafny_axioms/sets_declarations_dafny.smt2 [Seq[Ref]]
(declare-fun $Set.in ($Seq<$Ref> $Set<$Seq<$Ref>>) Bool)
(declare-fun $Set.card ($Set<$Seq<$Ref>>) Int)
(declare-fun $Set.empty<$Seq<$Ref>> () $Set<$Seq<$Ref>>)
(declare-fun $Set.singleton ($Seq<$Ref>) $Set<$Seq<$Ref>>)
(declare-fun $Set.unionone ($Set<$Seq<$Ref>> $Seq<$Ref>) $Set<$Seq<$Ref>>)
(declare-fun $Set.union ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) $Set<$Seq<$Ref>>)
(declare-fun $Set.disjoint ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) Bool)
(declare-fun $Set.difference ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) $Set<$Seq<$Ref>>)
(declare-fun $Set.intersection ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) $Set<$Seq<$Ref>>)
(declare-fun $Set.subset ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) Bool)
(declare-fun $Set.equal ($Set<$Seq<$Ref>> $Set<$Seq<$Ref>>) Bool)
; /dafny_axioms/sets_declarations_dafny.smt2 [Int]
(declare-fun $Set.in (Int $Set<Int>) Bool)
(declare-fun $Set.card ($Set<Int>) Int)
(declare-fun $Set.empty<Int> () $Set<Int>)
(declare-fun $Set.singleton (Int) $Set<Int>)
(declare-fun $Set.unionone ($Set<Int> Int) $Set<Int>)
(declare-fun $Set.union ($Set<Int> $Set<Int>) $Set<Int>)
(declare-fun $Set.disjoint ($Set<Int> $Set<Int>) Bool)
(declare-fun $Set.difference ($Set<Int> $Set<Int>) $Set<Int>)
(declare-fun $Set.intersection ($Set<Int> $Set<Int>) $Set<Int>)
(declare-fun $Set.subset ($Set<Int> $Set<Int>) Bool)
(declare-fun $Set.equal ($Set<Int> $Set<Int>) Bool)
; /dafny_axioms/sequences_declarations_dafny.smt2 [Ref]
(declare-fun $Seq.length ($Seq<$Ref>) Int)
(declare-fun $Seq.empty<$Ref> () $Seq<$Ref>)
(declare-fun $Seq.singleton ($Ref) $Seq<$Ref>)
(declare-fun $Seq.build ($Seq<$Ref> $Ref) $Seq<$Ref>)
(declare-fun $Seq.index ($Seq<$Ref> Int) $Ref)
(declare-fun $Seq.append ($Seq<$Ref> $Seq<$Ref>) $Seq<$Ref>)
(declare-fun $Seq.update ($Seq<$Ref> Int $Ref) $Seq<$Ref>)
(declare-fun $Seq.contains ($Seq<$Ref> $Ref) Bool)
(declare-fun $Seq.take ($Seq<$Ref> Int) $Seq<$Ref>)
(declare-fun $Seq.drop ($Seq<$Ref> Int) $Seq<$Ref>)
(declare-fun $Seq.equal ($Seq<$Ref> $Seq<$Ref>) Bool)
(declare-fun $Seq.sameuntil ($Seq<$Ref> $Seq<$Ref> Int) Bool)
; /dafny_axioms/sequences_declarations_dafny.smt2 [Int]
(declare-fun $Seq.length ($Seq<Int>) Int)
(declare-fun $Seq.empty<Int> () $Seq<Int>)
(declare-fun $Seq.singleton (Int) $Seq<Int>)
(declare-fun $Seq.build ($Seq<Int> Int) $Seq<Int>)
(declare-fun $Seq.index ($Seq<Int> Int) Int)
(declare-fun $Seq.append ($Seq<Int> $Seq<Int>) $Seq<Int>)
(declare-fun $Seq.update ($Seq<Int> Int Int) $Seq<Int>)
(declare-fun $Seq.contains ($Seq<Int> Int) Bool)
(declare-fun $Seq.take ($Seq<Int> Int) $Seq<Int>)
(declare-fun $Seq.drop ($Seq<Int> Int) $Seq<Int>)
(declare-fun $Seq.equal ($Seq<Int> $Seq<Int>) Bool)
(declare-fun $Seq.sameuntil ($Seq<Int> $Seq<Int> Int) Bool)
; /dafny_axioms/sequences_int_declarations_dafny.smt2
(declare-fun $Seq.range (Int Int) $Seq<Int>)
(assert true)
; /field_value_functions_declarations.smt2 [value: Int]
(declare-fun $FVF.domain_value ($FVF<Int>) $Set<$Ref>)
(declare-fun $FVF.lookup_value ($FVF<Int> $Ref) Int)
; /field_value_functions_declarations.smt2 [prev: Ref]
(declare-fun $FVF.domain_prev ($FVF<$Ref>) $Set<$Ref>)
(declare-fun $FVF.lookup_prev ($FVF<$Ref> $Ref) $Ref)
; /field_value_functions_declarations.smt2 [next: Ref]
(declare-fun $FVF.domain_next ($FVF<$Ref>) $Set<$Ref>)
(declare-fun $FVF.lookup_next ($FVF<$Ref> $Ref) $Ref)
; /field_value_functions_declarations.smt2 [nodes: Seq[Ref]]
(declare-fun $FVF.domain_nodes ($FVF<$Seq<$Ref>>) $Set<$Ref>)
(declare-fun $FVF.lookup_nodes ($FVF<$Seq<$Ref>> $Ref) $Seq<$Ref>)
; /dafny_axioms/sequences_axioms_dafny.smt2 [Ref]
(assert (forall ((s $Seq<$Ref>) ) (! (<= 0 ($Seq.length s))
:pattern ( ($Seq.length s))
)))
(assert (= ($Seq.length $Seq.empty<$Ref>) 0))
(assert (forall ((s $Seq<$Ref>) ) (! (=> (= ($Seq.length s) 0) (= s $Seq.empty<$Ref>))
:pattern ( ($Seq.length s))
)))
(assert (forall ((t $Ref) ) (! (= ($Seq.length ($Seq.singleton t)) 1)
:pattern ( ($Seq.length ($Seq.singleton t)))
)))
(assert (forall ((s $Seq<$Ref>) (v $Ref) ) (! (= ($Seq.length ($Seq.build s v)) (+ 1 ($Seq.length s)))
:pattern ( ($Seq.length ($Seq.build s v)))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) ) (! (and
(=> (= i ($Seq.length s)) (= ($Seq.index ($Seq.build s v) i) v))
(=> (not (= i ($Seq.length s))) (= ($Seq.index ($Seq.build s v) i) ($Seq.index s i))))
:pattern ( ($Seq.index ($Seq.build s v) i))
)))
(assert (forall ((s0 $Seq<$Ref>) (s1 $Seq<$Ref>) ) (! (= ($Seq.length ($Seq.append s0 s1)) (+ ($Seq.length s0) ($Seq.length s1)))
:pattern ( ($Seq.length ($Seq.append s0 s1)))
)))
(assert (forall ((t $Ref) ) (! (= ($Seq.index ($Seq.singleton t) 0) t)
:pattern ( ($Seq.index ($Seq.singleton t) 0))
)))
(assert (forall ((s0 $Seq<$Ref>) (s1 $Seq<$Ref>) (n Int) ) (! (and
(=> (< n ($Seq.length s0)) (= ($Seq.index ($Seq.append s0 s1) n) ($Seq.index s0 n)))
(=> (<= ($Seq.length s0) n) (= ($Seq.index ($Seq.append s0 s1) n) ($Seq.index s1 (- n ($Seq.length s0))))))
:pattern ( ($Seq.index ($Seq.append s0 s1) n))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) ) (! (=> (and
(<= 0 i)
(< i ($Seq.length s))) (= ($Seq.length ($Seq.update s i v)) ($Seq.length s)))
:pattern ( ($Seq.length ($Seq.update s i v)))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) (n Int) ) (! (=> (and
(<= 0 n)
(< n ($Seq.length s))) (and
(=> (= i n) (= ($Seq.index ($Seq.update s i v) n) v))
(=> (not (= i n)) (= ($Seq.index ($Seq.update s i v) n) ($Seq.index s n)))))
:pattern ( ($Seq.index ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<$Ref>) (x $Ref) ) (!
(and
(=>
($Seq.contains s x)
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains s x)))
:pattern ( ($Seq.contains s x))
)))
(assert (forall ((x $Ref) ) (! (not ($Seq.contains $Seq.empty<$Ref> x))
:pattern ( ($Seq.contains $Seq.empty<$Ref> x))
)))
(assert (forall ((s0 $Seq<$Ref>) (s1 $Seq<$Ref>) (x $Ref) ) (! (and
(=> ($Seq.contains ($Seq.append s0 s1) x) (or
($Seq.contains s0 x)
($Seq.contains s1 x)))
(=> (or
($Seq.contains s0 x)
($Seq.contains s1 x)) ($Seq.contains ($Seq.append s0 s1) x)))
:pattern ( ($Seq.contains ($Seq.append s0 s1) x))
)))
(assert (forall ((s $Seq<$Ref>) (v $Ref) (x $Ref) ) (! (and
(=> ($Seq.contains ($Seq.build s v) x) (or
(= v x)
($Seq.contains s x)))
(=> (or
(= v x)
($Seq.contains s x)) ($Seq.contains ($Seq.build s v) x)))
:pattern ( ($Seq.contains ($Seq.build s v) x))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) (x $Ref) ) (!
(and
(=>
($Seq.contains ($Seq.take s n) x)
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i n)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i n)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains ($Seq.take s n) x)))
:pattern ( ($Seq.contains ($Seq.take s n) x))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) (x $Ref) ) (!
(and
(=>
($Seq.contains ($Seq.drop s n) x)
(exists ((i Int) ) (!
(and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains ($Seq.drop s n) x)))
:pattern ( ($Seq.contains ($Seq.drop s n) x))
)))
(assert (forall ((s0 $Seq<$Ref>) (s1 $Seq<$Ref>) ) (! (and
(=> ($Seq.equal s0 s1) (and
(= ($Seq.length s0) ($Seq.length s1))
(forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j ($Seq.length s0))) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
))))
(=> (and
(= ($Seq.length s0) ($Seq.length s1))
(forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j ($Seq.length s0))) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
))) ($Seq.equal s0 s1)))
:pattern ( ($Seq.equal s0 s1))
)))
(assert (forall ((a $Seq<$Ref>) (b $Seq<$Ref>) ) (! (=> ($Seq.equal a b) (= a b))
:pattern ( ($Seq.equal a b))
)))
(assert (forall ((s0 $Seq<$Ref>) (s1 $Seq<$Ref>) (n Int) ) (! (and
(=> ($Seq.sameuntil s0 s1 n) (forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j n)) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
)))
(=> (forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j n)) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
)) ($Seq.sameuntil s0 s1 n)))
:pattern ( ($Seq.sameuntil s0 s1 n))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) ) (! (=> (<= 0 n) (and
(=> (<= n ($Seq.length s)) (= ($Seq.length ($Seq.take s n)) n))
(=> (< ($Seq.length s) n) (= ($Seq.length ($Seq.take s n)) ($Seq.length s)))))
:pattern ( ($Seq.length ($Seq.take s n)))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) (j Int) ) (! (=> (and
(<= 0 j)
(< j n)
(< j ($Seq.length s))) (= ($Seq.index ($Seq.take s n) j) ($Seq.index s j)))
:pattern ( ($Seq.index ($Seq.take s n) j))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) ) (! (=> (<= 0 n) (and
(=> (<= n ($Seq.length s)) (= ($Seq.length ($Seq.drop s n)) (- ($Seq.length s) n)))
(=> (< ($Seq.length s) n) (= ($Seq.length ($Seq.drop s n)) 0))))
:pattern ( ($Seq.length ($Seq.drop s n)))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) (j Int) ) (! (=> (and
(<= 0 n)
(<= 0 j)
(< j (- ($Seq.length s) n))) (= ($Seq.index ($Seq.drop s n) j) ($Seq.index s (+ j n))))
:pattern ( ($Seq.index ($Seq.drop s n) j))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) (n Int) ) (! (=> (and
(<= 0 i)
(< i n)
(<= n ($Seq.length s))) (= ($Seq.take ($Seq.update s i v) n) ($Seq.update ($Seq.take s n) i v)))
:pattern ( ($Seq.take ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) (n Int) ) (! (=> (and
(<= n i)
(< i ($Seq.length s))) (= ($Seq.take ($Seq.update s i v) n) ($Seq.take s n)))
:pattern ( ($Seq.take ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) (n Int) ) (! (=> (and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))) (= ($Seq.drop ($Seq.update s i v) n) ($Seq.update ($Seq.drop s n) (- i n) v)))
:pattern ( ($Seq.drop ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<$Ref>) (i Int) (v $Ref) (n Int) ) (! (=> (and
(<= 0 i)
(< i n)
(< n ($Seq.length s))) (= ($Seq.drop ($Seq.update s i v) n) ($Seq.drop s n)))
:pattern ( ($Seq.drop ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<$Ref>) (v $Ref) (n Int) ) (! (=> (and
(<= 0 n)
(<= n ($Seq.length s))) (= ($Seq.drop ($Seq.build s v) n) ($Seq.build ($Seq.drop s n) v)))
:pattern ( ($Seq.drop ($Seq.build s v) n))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) ) (! (=> (= n 0) (= ($Seq.drop s n) s))
:pattern ( ($Seq.drop s n))
)))
(assert (forall ((s $Seq<$Ref>) (n Int) ) (! (=> (= n 0) (= ($Seq.take s n) $Seq.empty<$Ref>))
:pattern ( ($Seq.take s n))
)))
(assert (forall ((s $Seq<$Ref>) (m Int) (n Int) ) (! (=> (and
(<= 0 m)
(<= 0 n)
(<= (+ m n) ($Seq.length s))) (= ($Seq.drop ($Seq.drop s m) n) ($Seq.drop s (+ m n))))
:pattern ( ($Seq.drop ($Seq.drop s m) n))
)))
(assert (forall ((x $Ref) (y $Ref)) (!
(iff
($Seq.contains ($Seq.singleton x) y)
(= x y))
:pattern (($Seq.contains ($Seq.singleton x) y))
)))
; /dafny_axioms/sequences_axioms_dafny.smt2 [Int]
(assert (forall ((s $Seq<Int>) ) (! (<= 0 ($Seq.length s))
:pattern ( ($Seq.length s))
)))
(assert (= ($Seq.length $Seq.empty<Int>) 0))
(assert (forall ((s $Seq<Int>) ) (! (=> (= ($Seq.length s) 0) (= s $Seq.empty<Int>))
:pattern ( ($Seq.length s))
)))
(assert (forall ((t Int) ) (! (= ($Seq.length ($Seq.singleton t)) 1)
:pattern ( ($Seq.length ($Seq.singleton t)))
)))
(assert (forall ((s $Seq<Int>) (v Int) ) (! (= ($Seq.length ($Seq.build s v)) (+ 1 ($Seq.length s)))
:pattern ( ($Seq.length ($Seq.build s v)))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) ) (! (and
(=> (= i ($Seq.length s)) (= ($Seq.index ($Seq.build s v) i) v))
(=> (not (= i ($Seq.length s))) (= ($Seq.index ($Seq.build s v) i) ($Seq.index s i))))
:pattern ( ($Seq.index ($Seq.build s v) i))
)))
(assert (forall ((s0 $Seq<Int>) (s1 $Seq<Int>) ) (! (= ($Seq.length ($Seq.append s0 s1)) (+ ($Seq.length s0) ($Seq.length s1)))
:pattern ( ($Seq.length ($Seq.append s0 s1)))
)))
(assert (forall ((t Int) ) (! (= ($Seq.index ($Seq.singleton t) 0) t)
:pattern ( ($Seq.index ($Seq.singleton t) 0))
)))
(assert (forall ((s0 $Seq<Int>) (s1 $Seq<Int>) (n Int) ) (! (and
(=> (< n ($Seq.length s0)) (= ($Seq.index ($Seq.append s0 s1) n) ($Seq.index s0 n)))
(=> (<= ($Seq.length s0) n) (= ($Seq.index ($Seq.append s0 s1) n) ($Seq.index s1 (- n ($Seq.length s0))))))
:pattern ( ($Seq.index ($Seq.append s0 s1) n))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) ) (! (=> (and
(<= 0 i)
(< i ($Seq.length s))) (= ($Seq.length ($Seq.update s i v)) ($Seq.length s)))
:pattern ( ($Seq.length ($Seq.update s i v)))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) (n Int) ) (! (=> (and
(<= 0 n)
(< n ($Seq.length s))) (and
(=> (= i n) (= ($Seq.index ($Seq.update s i v) n) v))
(=> (not (= i n)) (= ($Seq.index ($Seq.update s i v) n) ($Seq.index s n)))))
:pattern ( ($Seq.index ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<Int>) (x Int) ) (!
(and
(=>
($Seq.contains s x)
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains s x)))
:pattern ( ($Seq.contains s x))
)))
(assert (forall ((x Int) ) (! (not ($Seq.contains $Seq.empty<Int> x))
:pattern ( ($Seq.contains $Seq.empty<Int> x))
)))
(assert (forall ((s0 $Seq<Int>) (s1 $Seq<Int>) (x Int) ) (! (and
(=> ($Seq.contains ($Seq.append s0 s1) x) (or
($Seq.contains s0 x)
($Seq.contains s1 x)))
(=> (or
($Seq.contains s0 x)
($Seq.contains s1 x)) ($Seq.contains ($Seq.append s0 s1) x)))
:pattern ( ($Seq.contains ($Seq.append s0 s1) x))
)))
(assert (forall ((s $Seq<Int>) (v Int) (x Int) ) (! (and
(=> ($Seq.contains ($Seq.build s v) x) (or
(= v x)
($Seq.contains s x)))
(=> (or
(= v x)
($Seq.contains s x)) ($Seq.contains ($Seq.build s v) x)))
:pattern ( ($Seq.contains ($Seq.build s v) x))
)))
(assert (forall ((s $Seq<Int>) (n Int) (x Int) ) (!
(and
(=>
($Seq.contains ($Seq.take s n) x)
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i n)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 i)
(< i n)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains ($Seq.take s n) x)))
:pattern ( ($Seq.contains ($Seq.take s n) x))
)))
(assert (forall ((s $Seq<Int>) (n Int) (x Int) ) (!
(and
(=>
($Seq.contains ($Seq.drop s n) x)
(exists ((i Int) ) (!
(and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
)))
(=>
(exists ((i Int) ) (!
(and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))
(= ($Seq.index s i) x))
:pattern ( ($Seq.index s i))
))
($Seq.contains ($Seq.drop s n) x)))
:pattern ( ($Seq.contains ($Seq.drop s n) x))
)))
(assert (forall ((s0 $Seq<Int>) (s1 $Seq<Int>) ) (! (and
(=> ($Seq.equal s0 s1) (and
(= ($Seq.length s0) ($Seq.length s1))
(forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j ($Seq.length s0))) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
))))
(=> (and
(= ($Seq.length s0) ($Seq.length s1))
(forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j ($Seq.length s0))) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
))) ($Seq.equal s0 s1)))
:pattern ( ($Seq.equal s0 s1))
)))
(assert (forall ((a $Seq<Int>) (b $Seq<Int>) ) (! (=> ($Seq.equal a b) (= a b))
:pattern ( ($Seq.equal a b))
)))
(assert (forall ((s0 $Seq<Int>) (s1 $Seq<Int>) (n Int) ) (! (and
(=> ($Seq.sameuntil s0 s1 n) (forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j n)) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
)))
(=> (forall ((j Int) ) (! (=> (and
(<= 0 j)
(< j n)) (= ($Seq.index s0 j) ($Seq.index s1 j)))
:pattern ( ($Seq.index s0 j))
:pattern ( ($Seq.index s1 j))
)) ($Seq.sameuntil s0 s1 n)))
:pattern ( ($Seq.sameuntil s0 s1 n))
)))
(assert (forall ((s $Seq<Int>) (n Int) ) (! (=> (<= 0 n) (and
(=> (<= n ($Seq.length s)) (= ($Seq.length ($Seq.take s n)) n))
(=> (< ($Seq.length s) n) (= ($Seq.length ($Seq.take s n)) ($Seq.length s)))))
:pattern ( ($Seq.length ($Seq.take s n)))
)))
(assert (forall ((s $Seq<Int>) (n Int) (j Int) ) (! (=> (and
(<= 0 j)
(< j n)
(< j ($Seq.length s))) (= ($Seq.index ($Seq.take s n) j) ($Seq.index s j)))
:pattern ( ($Seq.index ($Seq.take s n) j))
)))
(assert (forall ((s $Seq<Int>) (n Int) ) (! (=> (<= 0 n) (and
(=> (<= n ($Seq.length s)) (= ($Seq.length ($Seq.drop s n)) (- ($Seq.length s) n)))
(=> (< ($Seq.length s) n) (= ($Seq.length ($Seq.drop s n)) 0))))
:pattern ( ($Seq.length ($Seq.drop s n)))
)))
(assert (forall ((s $Seq<Int>) (n Int) (j Int) ) (! (=> (and
(<= 0 n)
(<= 0 j)
(< j (- ($Seq.length s) n))) (= ($Seq.index ($Seq.drop s n) j) ($Seq.index s (+ j n))))
:pattern ( ($Seq.index ($Seq.drop s n) j))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) (n Int) ) (! (=> (and
(<= 0 i)
(< i n)
(<= n ($Seq.length s))) (= ($Seq.take ($Seq.update s i v) n) ($Seq.update ($Seq.take s n) i v)))
:pattern ( ($Seq.take ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) (n Int) ) (! (=> (and
(<= n i)
(< i ($Seq.length s))) (= ($Seq.take ($Seq.update s i v) n) ($Seq.take s n)))
:pattern ( ($Seq.take ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) (n Int) ) (! (=> (and
(<= 0 n)
(<= n i)
(< i ($Seq.length s))) (= ($Seq.drop ($Seq.update s i v) n) ($Seq.update ($Seq.drop s n) (- i n) v)))
:pattern ( ($Seq.drop ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<Int>) (i Int) (v Int) (n Int) ) (! (=> (and
(<= 0 i)
(< i n)
(< n ($Seq.length s))) (= ($Seq.drop ($Seq.update s i v) n) ($Seq.drop s n)))
:pattern ( ($Seq.drop ($Seq.update s i v) n))
)))
(assert (forall ((s $Seq<Int>) (v Int) (n Int) ) (! (=> (and
(<= 0 n)
(<= n ($Seq.length s))) (= ($Seq.drop ($Seq.build s v) n) ($Seq.build ($Seq.drop s n) v)))
:pattern ( ($Seq.drop ($Seq.build s v) n))
)))
(assert (forall ((s $Seq<Int>) (n Int) ) (! (=> (= n 0) (= ($Seq.drop s n) s))
:pattern ( ($Seq.drop s n))
)))
(assert (forall ((s $Seq<Int>) (n Int) ) (! (=> (= n 0) (= ($Seq.take s n) $Seq.empty<Int>))
:pattern ( ($Seq.take s n))
)))
(assert (forall ((s $Seq<Int>) (m Int) (n Int) ) (! (=> (and
(<= 0 m)
(<= 0 n)
(<= (+ m n) ($Seq.length s))) (= ($Seq.drop ($Seq.drop s m) n) ($Seq.drop s (+ m n))))
:pattern ( ($Seq.drop ($Seq.drop s m) n))
)))
(assert (forall ((x Int) (y Int)) (!
(iff
($Seq.contains ($Seq.singleton x) y)
(= x y))
:pattern (($Seq.contains ($Seq.singleton x) y))
)))
; /dafny_axioms/sequences_int_axioms_dafny.smt2
(assert (forall ((min Int) (max Int) ) (! (and
(=> (< min max) (= ($Seq.length ($Seq.range min max)) (- max min)))
(=> (<= max min) (= ($Seq.length ($Seq.range min max)) 0)))
:pattern ( ($Seq.length ($Seq.range min max)))
)))
(assert (forall ((min Int) (max Int) (j Int) ) (! (=> (and
(<= 0 j)
(< j (- max min))) (= ($Seq.index ($Seq.range min max) j) (+ min j)))
:pattern ( ($Seq.index ($Seq.range min max) j))
)))
(assert (forall ((min Int) (max Int) (v Int) ) (! (and
(=> ($Seq.contains ($Seq.range min max) v) (and
(<= min v)
(< v max)))
(=> (and
(<= min v)
(< v max)) ($Seq.contains ($Seq.range min max) v)))
:pattern ( ($Seq.contains ($Seq.range min max) v))
)))
; /dafny_axioms/sets_axioms_dafny.smt2 [Ref]
(assert (forall ((s $Set<$Ref>)) (!
(<= 0 ($Set.card s))
:pattern (($Set.card s))
)))
(assert (forall ((o $Ref)) (!
(not ($Set.in o $Set.empty<$Ref>))
:pattern (($Set.in o $Set.empty<$Ref>))
)))
(assert (forall ((s $Set<$Ref>)) (!
(and
(iff
(= ($Set.card s) 0)
(= s $Set.empty<$Ref>))
(implies
(not (= ($Set.card s) 0))
(exists ((x $Ref)) (!
($Set.in x s)
:pattern (($Set.in x s))
))))
:pattern (($Set.card s))
)))
(assert (forall ((r $Ref)) (!
($Set.in r ($Set.singleton r))
:pattern (($Set.in r ($Set.singleton r)))
)))
(assert (forall ((r $Ref) (o $Ref)) (!
(iff
($Set.in o ($Set.singleton r))
(= r o))
:pattern (($Set.in o ($Set.singleton r)))
)))
(assert (forall ((r $Ref)) (!
(= ($Set.card ($Set.singleton r)) 1)
:pattern (($Set.card ($Set.singleton r)))
)))
(assert (forall ((a $Set<$Ref>) (x $Ref) (o $Ref)) (!
(iff
($Set.in o ($Set.unionone a x))
(or
(= o x)
($Set.in o a)))
:pattern (($Set.in o ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Ref>) (x $Ref)) (!
($Set.in x ($Set.unionone a x))
:pattern (($Set.in x ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Ref>) (x $Ref) (y $Ref)) (!
(=>
($Set.in y a)
($Set.in y ($Set.unionone a x)))
:pattern (($Set.in y a) ($Set.in y ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Ref>) (x $Ref)) (!
(=>
($Set.in x a)
(= ($Set.card ($Set.unionone a x)) ($Set.card a)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Ref>) (x $Ref)) (!
(=>
(not ($Set.in x a))
(= ($Set.card ($Set.unionone a x)) (+ ($Set.card a) 1)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (o $Ref)) (!
(iff
($Set.in o ($Set.union a b))
(or
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.union a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (y $Ref)) (!
(=>
($Set.in y a)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y a))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (y $Ref)) (!
(=>
($Set.in y b)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (o $Ref)) (!
(iff
($Set.in o ($Set.intersection a b))
(and
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=
($Set.union ($Set.union a b) b)
($Set.union a b))
:pattern (($Set.union ($Set.union a b) b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=
($Set.union a ($Set.union a b))
($Set.union a b))
:pattern (($Set.union a ($Set.union a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=
($Set.intersection ($Set.intersection a b) b)
($Set.intersection a b))
:pattern (($Set.intersection ($Set.intersection a b) b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=
($Set.intersection a ($Set.intersection a b))
($Set.intersection a b))
:pattern (($Set.intersection a ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=
(+
($Set.card ($Set.union a b))
($Set.card ($Set.intersection a b)))
(+
($Set.card a)
($Set.card b)))
:pattern (($Set.card ($Set.union a b)))
:pattern (($Set.card ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (o $Ref)) (!
(iff
($Set.in o ($Set.difference a b))
(and
($Set.in o a)
(not ($Set.in o b))))
:pattern (($Set.in o ($Set.difference a b)))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>) (y $Ref)) (!
(=>
($Set.in y b)
(not ($Set.in y ($Set.difference a b))))
:pattern (($Set.in y ($Set.difference a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(iff
($Set.subset a b)
(forall ((o $Ref)) (!
(=>
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.subset a b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(iff
($Set.equal a b)
(forall ((o $Ref)) (!
(iff
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(=>
($Set.equal a b)
(= a b))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(iff
($Set.disjoint a b)
(forall ((o $Ref)) (!
(or
(not ($Set.in o a))
(not ($Set.in o b)))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.disjoint a b))
)))
(assert (forall ((a $Set<$Ref>) (b $Set<$Ref>)) (!
(and
(=
(+
(+
($Set.card ($Set.difference a b))
($Set.card ($Set.difference b a)))
($Set.card ($Set.intersection a b)))
($Set.card ($Set.union a b)))
(=
($Set.card ($Set.difference a b))
(-
($Set.card a)
($Set.card ($Set.intersection a b)))))
:pattern (($Set.card ($Set.difference a b)) ($Set.card ($Set.intersection a b)))
)))
; /dafny_axioms/sets_axioms_dafny.smt2 [Seq[Ref]]
(assert (forall ((s $Set<$Seq<$Ref>>)) (!
(<= 0 ($Set.card s))
:pattern (($Set.card s))
)))
(assert (forall ((o $Seq<$Ref>)) (!
(not ($Set.in o $Set.empty<$Seq<$Ref>>))
:pattern (($Set.in o $Set.empty<$Seq<$Ref>>))
)))
(assert (forall ((s $Set<$Seq<$Ref>>)) (!
(and
(iff
(= ($Set.card s) 0)
(= s $Set.empty<$Seq<$Ref>>))
(implies
(not (= ($Set.card s) 0))
(exists ((x $Seq<$Ref>)) (!
($Set.in x s)
:pattern (($Set.in x s))
))))
:pattern (($Set.card s))
)))
(assert (forall ((r $Seq<$Ref>)) (!
($Set.in r ($Set.singleton r))
:pattern (($Set.in r ($Set.singleton r)))
)))
(assert (forall ((r $Seq<$Ref>) (o $Seq<$Ref>)) (!
(iff
($Set.in o ($Set.singleton r))
(= r o))
:pattern (($Set.in o ($Set.singleton r)))
)))
(assert (forall ((r $Seq<$Ref>)) (!
(= ($Set.card ($Set.singleton r)) 1)
:pattern (($Set.card ($Set.singleton r)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (x $Seq<$Ref>) (o $Seq<$Ref>)) (!
(iff
($Set.in o ($Set.unionone a x))
(or
(= o x)
($Set.in o a)))
:pattern (($Set.in o ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (x $Seq<$Ref>)) (!
($Set.in x ($Set.unionone a x))
:pattern (($Set.in x ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (x $Seq<$Ref>) (y $Seq<$Ref>)) (!
(=>
($Set.in y a)
($Set.in y ($Set.unionone a x)))
:pattern (($Set.in y a) ($Set.in y ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (x $Seq<$Ref>)) (!
(=>
($Set.in x a)
(= ($Set.card ($Set.unionone a x)) ($Set.card a)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (x $Seq<$Ref>)) (!
(=>
(not ($Set.in x a))
(= ($Set.card ($Set.unionone a x)) (+ ($Set.card a) 1)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (o $Seq<$Ref>)) (!
(iff
($Set.in o ($Set.union a b))
(or
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.union a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (y $Seq<$Ref>)) (!
(=>
($Set.in y a)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y a))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (y $Seq<$Ref>)) (!
(=>
($Set.in y b)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (o $Seq<$Ref>)) (!
(iff
($Set.in o ($Set.intersection a b))
(and
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=
($Set.union ($Set.union a b) b)
($Set.union a b))
:pattern (($Set.union ($Set.union a b) b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=
($Set.union a ($Set.union a b))
($Set.union a b))
:pattern (($Set.union a ($Set.union a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=
($Set.intersection ($Set.intersection a b) b)
($Set.intersection a b))
:pattern (($Set.intersection ($Set.intersection a b) b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=
($Set.intersection a ($Set.intersection a b))
($Set.intersection a b))
:pattern (($Set.intersection a ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=
(+
($Set.card ($Set.union a b))
($Set.card ($Set.intersection a b)))
(+
($Set.card a)
($Set.card b)))
:pattern (($Set.card ($Set.union a b)))
:pattern (($Set.card ($Set.intersection a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (o $Seq<$Ref>)) (!
(iff
($Set.in o ($Set.difference a b))
(and
($Set.in o a)
(not ($Set.in o b))))
:pattern (($Set.in o ($Set.difference a b)))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>) (y $Seq<$Ref>)) (!
(=>
($Set.in y b)
(not ($Set.in y ($Set.difference a b))))
:pattern (($Set.in y ($Set.difference a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(iff
($Set.subset a b)
(forall ((o $Seq<$Ref>)) (!
(=>
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.subset a b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(iff
($Set.equal a b)
(forall ((o $Seq<$Ref>)) (!
(iff
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(=>
($Set.equal a b)
(= a b))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(iff
($Set.disjoint a b)
(forall ((o $Seq<$Ref>)) (!
(or
(not ($Set.in o a))
(not ($Set.in o b)))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.disjoint a b))
)))
(assert (forall ((a $Set<$Seq<$Ref>>) (b $Set<$Seq<$Ref>>)) (!
(and
(=
(+
(+
($Set.card ($Set.difference a b))
($Set.card ($Set.difference b a)))
($Set.card ($Set.intersection a b)))
($Set.card ($Set.union a b)))
(=
($Set.card ($Set.difference a b))
(-
($Set.card a)
($Set.card ($Set.intersection a b)))))
:pattern (($Set.card ($Set.difference a b)) ($Set.card ($Set.intersection a b)))
)))
; /dafny_axioms/sets_axioms_dafny.smt2 [Int]
(assert (forall ((s $Set<Int>)) (!
(<= 0 ($Set.card s))
:pattern (($Set.card s))
)))
(assert (forall ((o Int)) (!
(not ($Set.in o $Set.empty<Int>))
:pattern (($Set.in o $Set.empty<Int>))
)))
(assert (forall ((s $Set<Int>)) (!
(and
(iff
(= ($Set.card s) 0)
(= s $Set.empty<Int>))
(implies
(not (= ($Set.card s) 0))
(exists ((x Int)) (!
($Set.in x s)
:pattern (($Set.in x s))
))))
:pattern (($Set.card s))
)))
(assert (forall ((r Int)) (!
($Set.in r ($Set.singleton r))
:pattern (($Set.in r ($Set.singleton r)))
)))
(assert (forall ((r Int) (o Int)) (!
(iff
($Set.in o ($Set.singleton r))
(= r o))
:pattern (($Set.in o ($Set.singleton r)))
)))
(assert (forall ((r Int)) (!
(= ($Set.card ($Set.singleton r)) 1)
:pattern (($Set.card ($Set.singleton r)))
)))
(assert (forall ((a $Set<Int>) (x Int) (o Int)) (!
(iff
($Set.in o ($Set.unionone a x))
(or
(= o x)
($Set.in o a)))
:pattern (($Set.in o ($Set.unionone a x)))
)))
(assert (forall ((a $Set<Int>) (x Int)) (!
($Set.in x ($Set.unionone a x))
:pattern (($Set.in x ($Set.unionone a x)))
)))
(assert (forall ((a $Set<Int>) (x Int) (y Int)) (!
(=>
($Set.in y a)
($Set.in y ($Set.unionone a x)))
:pattern (($Set.in y a) ($Set.in y ($Set.unionone a x)))
)))
(assert (forall ((a $Set<Int>) (x Int)) (!
(=>
($Set.in x a)
(= ($Set.card ($Set.unionone a x)) ($Set.card a)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<Int>) (x Int)) (!
(=>
(not ($Set.in x a))
(= ($Set.card ($Set.unionone a x)) (+ ($Set.card a) 1)))
:pattern (($Set.card ($Set.unionone a x)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (o Int)) (!
(iff
($Set.in o ($Set.union a b))
(or
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.union a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (y Int)) (!
(=>
($Set.in y a)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y a))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (y Int)) (!
(=>
($Set.in y b)
($Set.in y ($Set.union a b)))
:pattern (($Set.in y ($Set.union a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (o Int)) (!
(iff
($Set.in o ($Set.intersection a b))
(and
($Set.in o a)
($Set.in o b)))
:pattern (($Set.in o ($Set.intersection a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=
($Set.union ($Set.union a b) b)
($Set.union a b))
:pattern (($Set.union ($Set.union a b) b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=
($Set.union a ($Set.union a b))
($Set.union a b))
:pattern (($Set.union a ($Set.union a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=
($Set.intersection ($Set.intersection a b) b)
($Set.intersection a b))
:pattern (($Set.intersection ($Set.intersection a b) b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=
($Set.intersection a ($Set.intersection a b))
($Set.intersection a b))
:pattern (($Set.intersection a ($Set.intersection a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=
(+
($Set.card ($Set.union a b))
($Set.card ($Set.intersection a b)))
(+
($Set.card a)
($Set.card b)))
:pattern (($Set.card ($Set.union a b)))
:pattern (($Set.card ($Set.intersection a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (o Int)) (!
(iff
($Set.in o ($Set.difference a b))
(and
($Set.in o a)
(not ($Set.in o b))))
:pattern (($Set.in o ($Set.difference a b)))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>) (y Int)) (!
(=>
($Set.in y b)
(not ($Set.in y ($Set.difference a b))))
:pattern (($Set.in y ($Set.difference a b)) ($Set.in y b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(iff
($Set.subset a b)
(forall ((o Int)) (!
(=>
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.subset a b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(iff
($Set.equal a b)
(forall ((o Int)) (!
(iff
($Set.in o a)
($Set.in o b))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(=>
($Set.equal a b)
(= a b))
:pattern (($Set.equal a b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(iff
($Set.disjoint a b)
(forall ((o Int)) (!
(or
(not ($Set.in o a))
(not ($Set.in o b)))
:pattern (($Set.in o a))
:pattern (($Set.in o b))
)))
:pattern (($Set.disjoint a b))
)))
(assert (forall ((a $Set<Int>) (b $Set<Int>)) (!
(and
(=
(+
(+
($Set.card ($Set.difference a b))
($Set.card ($Set.difference b a)))
($Set.card ($Set.intersection a b)))
($Set.card ($Set.union a b)))
(=
($Set.card ($Set.difference a b))
(-
($Set.card a)
($Set.card ($Set.intersection a b)))))
:pattern (($Set.card ($Set.difference a b)) ($Set.card ($Set.intersection a b)))
)))
; /field_value_functions_axioms.smt2 [value: Int]
(assert (forall ((vs $FVF<Int>) (ws $FVF<Int>)) (!
(implies
(and
($Set.equal ($FVF.domain_value vs) ($FVF.domain_value ws))
(forall ((x $Ref)) (!
(implies
($Set.in x ($FVF.domain_value vs))
(= ($FVF.lookup_value vs x) ($FVF.lookup_value ws x)))
:pattern (($FVF.lookup_value vs x) ($FVF.lookup_value ws x)))))
(= vs ws))
:pattern (($FVF.domain_value vs) ($FVF.domain_value ws)))))
; /field_value_functions_axioms.smt2 [prev: Ref]
(assert (forall ((vs $FVF<$Ref>) (ws $FVF<$Ref>)) (!
(implies
(and
($Set.equal ($FVF.domain_prev vs) ($FVF.domain_prev ws))
(forall ((x $Ref)) (!
(implies
($Set.in x ($FVF.domain_prev vs))
(= ($FVF.lookup_prev vs x) ($FVF.lookup_prev ws x)))
:pattern (($FVF.lookup_prev vs x) ($FVF.lookup_prev ws x)))))
(= vs ws))
:pattern (($FVF.domain_prev vs) ($FVF.domain_prev ws)))))
; /field_value_functions_axioms.smt2 [next: Ref]
(assert (forall ((vs $FVF<$Ref>) (ws $FVF<$Ref>)) (!
(implies
(and
($Set.equal ($FVF.domain_next vs) ($FVF.domain_next ws))
(forall ((x $Ref)) (!
(implies
($Set.in x ($FVF.domain_next vs))
(= ($FVF.lookup_next vs x) ($FVF.lookup_next ws x)))
:pattern (($FVF.lookup_next vs x) ($FVF.lookup_next ws x)))))
(= vs ws))
:pattern (($FVF.domain_next vs) ($FVF.domain_next ws)))))
; /field_value_functions_axioms.smt2 [nodes: Seq[Ref]]
(assert (forall ((vs $FVF<$Seq<$Ref>>) (ws $FVF<$Seq<$Ref>>)) (!
(implies
(and
($Set.equal ($FVF.domain_nodes vs) ($FVF.domain_nodes ws))
(forall ((x $Ref)) (!
(implies
($Set.in x ($FVF.domain_nodes vs))
(= ($FVF.lookup_nodes vs x) ($FVF.lookup_nodes ws x)))
:pattern (($FVF.lookup_nodes vs x) ($FVF.lookup_nodes ws x)))))
(= vs ws))
:pattern (($FVF.domain_nodes vs) ($FVF.domain_nodes ws)))))
; Declaring additional sort wrappers
(declare-fun $SortWrappers.$PermTo$Snap ($Perm) $Snap)
(declare-fun $SortWrappers.$SnapTo$Perm ($Snap) $Perm)
(assert (forall ((x $Perm)) (!
(= x ($SortWrappers.$SnapTo$Perm($SortWrappers.$PermTo$Snap x)))
:pattern (($SortWrappers.$PermTo$Snap x))
)))
(declare-fun $SortWrappers.$RefTo$Snap ($Ref) $Snap)
(declare-fun $SortWrappers.$SnapTo$Ref ($Snap) $Ref)
(assert (forall ((x $Ref)) (!
(= x ($SortWrappers.$SnapTo$Ref($SortWrappers.$RefTo$Snap x)))
:pattern (($SortWrappers.$RefTo$Snap x))
)))
(declare-fun $SortWrappers.BoolTo$Snap (Bool) $Snap)
(declare-fun $SortWrappers.$SnapToBool ($Snap) Bool)
(assert (forall ((x Bool)) (!
(= x ($SortWrappers.$SnapToBool($SortWrappers.BoolTo$Snap x)))
:pattern (($SortWrappers.BoolTo$Snap x))
)))
(declare-fun $SortWrappers.IntTo$Snap (Int) $Snap)
(declare-fun $SortWrappers.$SnapToInt ($Snap) Int)
(assert (forall ((x Int)) (!
(= x ($SortWrappers.$SnapToInt($SortWrappers.IntTo$Snap x)))
:pattern (($SortWrappers.IntTo$Snap x))
)))
; Declaring additional sort wrappers
(declare-fun $SortWrappers.$Seq<Int>To$Snap ($Seq<Int>) $Snap)
(declare-fun $SortWrappers.$SnapTo$Seq<Int> ($Snap) $Seq<Int>)
(assert (forall ((x $Seq<Int>)) (!
(= x ($SortWrappers.$SnapTo$Seq<Int>($SortWrappers.$Seq<Int>To$Snap x)))
:pattern (($SortWrappers.$Seq<Int>To$Snap x))
)))
(declare-fun $SortWrappers.$Seq<$Ref>To$Snap ($Seq<$Ref>) $Snap)
(declare-fun $SortWrappers.$SnapTo$Seq<$Ref> ($Snap) $Seq<$Ref>)
(assert (forall ((x $Seq<$Ref>)) (!
(= x ($SortWrappers.$SnapTo$Seq<$Ref>($SortWrappers.$Seq<$Ref>To$Snap x)))
:pattern (($SortWrappers.$Seq<$Ref>To$Snap x))
)))
; Declaring additional sort wrappers
(declare-fun $SortWrappers.$Set<Int>To$Snap ($Set<Int>) $Snap)
(declare-fun $SortWrappers.$SnapTo$Set<Int> ($Snap) $Set<Int>)
(assert (forall ((x $Set<Int>)) (!
(= x ($SortWrappers.$SnapTo$Set<Int>($SortWrappers.$Set<Int>To$Snap x)))
:pattern (($SortWrappers.$Set<Int>To$Snap x))
)))
(declare-fun $SortWrappers.$Set<$Seq<$Ref>>To$Snap ($Set<$Seq<$Ref>>) $Snap)
(declare-fun $SortWrappers.$SnapTo$Set<$Seq<$Ref>> ($Snap) $Set<$Seq<$Ref>>)
(assert (forall ((x $Set<$Seq<$Ref>>)) (!
(= x ($SortWrappers.$SnapTo$Set<$Seq<$Ref>>($SortWrappers.$Set<$Seq<$Ref>>To$Snap x)))
:pattern (($SortWrappers.$Set<$Seq<$Ref>>To$Snap x))
)))
(declare-fun $SortWrappers.$Set<$Ref>To$Snap ($Set<$Ref>) $Snap)
(declare-fun $SortWrappers.$SnapTo$Set<$Ref> ($Snap) $Set<$Ref>)
(assert (forall ((x $Set<$Ref>)) (!
(= x ($SortWrappers.$SnapTo$Set<$Ref>($SortWrappers.$Set<$Ref>To$Snap x)))
:pattern (($SortWrappers.$Set<$Ref>To$Snap x))
)))
; Declaring additional sort wrappers
(declare-fun $SortWrappers.$FVF<$Seq<$Ref>>To$Snap ($FVF<$Seq<$Ref>>) $Snap)
(declare-fun $SortWrappers.$SnapTo$FVF<$Seq<$Ref>> ($Snap) $FVF<$Seq<$Ref>>)
(assert (forall ((x $FVF<$Seq<$Ref>>)) (!
(= x ($SortWrappers.$SnapTo$FVF<$Seq<$Ref>>($SortWrappers.$FVF<$Seq<$Ref>>To$Snap x)))
:pattern (($SortWrappers.$FVF<$Seq<$Ref>>To$Snap x))
)))
(declare-fun $SortWrappers.$FVF<$Ref>To$Snap ($FVF<$Ref>) $Snap)
(declare-fun $SortWrappers.$SnapTo$FVF<$Ref> ($Snap) $FVF<$Ref>)
(assert (forall ((x $FVF<$Ref>)) (!
(= x ($SortWrappers.$SnapTo$FVF<$Ref>($SortWrappers.$FVF<$Ref>To$Snap x)))
:pattern (($SortWrappers.$FVF<$Ref>To$Snap x))
)))
(declare-fun $SortWrappers.$FVF<Int>To$Snap ($FVF<Int>) $Snap)
(declare-fun $SortWrappers.$SnapTo$FVF<Int> ($Snap) $FVF<Int>)
(assert (forall ((x $FVF<Int>)) (!
(= x ($SortWrappers.$SnapTo$FVF<Int>($SortWrappers.$FVF<Int>To$Snap x)))
:pattern (($SortWrappers.$FVF<Int>To$Snap x))
)))
; Preamble end
; ------------------------------------------------------------
; ------------------------------------------------------------
; Declaring program functions
(declare-const s@$ $Snap)
; ---------- addBefore ----------
(declare-const this@1 $Ref)
(declare-const i@2 Int)
(declare-const n@3 $Ref)
(declare-const newNode@4 $Ref)
(declare-const index@5 Int)
(push) ; 2
(declare-const $t@6 $Snap)
; [eval] (unfolding acc(Valid(this), write) in (n in this.nodes))
(declare-const $t@7 $Ref)
(declare-const $t@8 $Snap)
(assert (= $t@6 ($Snap.combine ($SortWrappers.$RefTo$Snap $t@7) $t@8)))
(assert (not (= this@1 $Ref.null)))
(declare-const $t@9 $Seq<$Ref>)
(declare-const $t@10 $Snap)
(assert (= $t@8 ($Snap.combine ($SortWrappers.$Seq<$Ref>To$Snap $t@9) $t@10)))
(declare-const $t@11 $Snap)
(assert (= $t@10 ($Snap.combine $Snap.unit $t@11)))
; [eval] (this.header in this.nodes)
(assert ($Seq.contains $t@9 $t@7))
(declare-const $t@12 $Snap)
(assert (= $t@11 ($Snap.combine $Snap.unit $t@12)))
; [eval] !(null in this.nodes)
; [eval] (null in this.nodes)
(assert (not ($Seq.contains $t@9 $Ref.null)))
(declare-const $t@13 $Snap)
(assert (= $t@12 ($Snap.combine $Snap.unit $t@13)))
; [eval] 0 < |this.nodes|
; [eval] |this.nodes|
(assert (< 0 ($Seq.length $t@9)))
(declare-const $t@14 $Snap)
(assert (= $t@13 ($Snap.combine $Snap.unit $t@14)))
; [eval] this.header == this.nodes[0]
; [eval] this.nodes[0]
(assert (= $t@7 ($Seq.index $t@9 0)))
(declare-const $t@15 $FVF<$Ref>)
(declare-const $t@16 $Snap)
(assert (= $t@14 ($Snap.combine ($SortWrappers.$FVF<$Ref>To$Snap $t@15) $t@16)))
(declare-const i@17 Int)
(push) ; 3
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@17))
; [eval] this.nodes[i]
(pop) ; 3
(declare-fun inv@18 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@18 $r))
(= ($Seq.index $t@9 (inv@18 $r)) $r))
:pattern (($Seq.index $t@9 (inv@18 $r))))))
(assert (forall ((i@17 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@17)
(= (inv@18 ($Seq.index $t@9 i@17)) i@17))
:pattern (($Seq.index $t@9 i@17)))))
(assert (forall ((i@17 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@17)
(not (= ($Seq.index $t@9 i@17) $Ref.null)))
:pattern (($Seq.index $t@9 i@17)))))
(assert (forall ((i@17 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@17)
($Set.in ($Seq.index $t@9 i@17) ($FVF.domain_next $t@15)))
:pattern (($FVF.lookup_next $t@15 ($Seq.index $t@9 i@17))))))
(declare-const $t@19 $FVF<$Ref>)
(declare-const $t@20 $FVF<Int>)
(assert (=
$t@16
($Snap.combine
($SortWrappers.$FVF<$Ref>To$Snap $t@19)
($SortWrappers.$FVF<Int>To$Snap $t@20))))
(declare-const i@21 Int)
(push) ; 3
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@21))
; [eval] this.nodes[i]
(pop) ; 3
(declare-fun inv@22 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@22 $r))
(= ($Seq.index $t@9 (inv@22 $r)) $r))
:pattern (($Seq.index $t@9 (inv@22 $r))))))
(assert (forall ((i@21 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@21)
(= (inv@22 ($Seq.index $t@9 i@21)) i@21))
:pattern (($Seq.index $t@9 i@21)))))
(assert (forall ((i@21 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@21)
(not (= ($Seq.index $t@9 i@21) $Ref.null)))
:pattern (($Seq.index $t@9 i@21)))))
(assert (forall ((i@21 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@21)
($Set.in ($Seq.index $t@9 i@21) ($FVF.domain_prev $t@19)))
:pattern (($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@21))))))
(declare-const $t@23 $FVF<Int>)
(assert (=
($SortWrappers.$FVF<Int>To$Snap $t@20)
($Snap.combine ($SortWrappers.$FVF<Int>To$Snap $t@23) $Snap.unit)))
(declare-const i@24 Int)
(push) ; 3
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@24))
; [eval] this.nodes[i]
(pop) ; 3
(declare-fun inv@25 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@25 $r))
(= ($Seq.index $t@9 (inv@25 $r)) $r))
:pattern (($Seq.index $t@9 (inv@25 $r))))))
(assert (forall ((i@24 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@24)
(= (inv@25 ($Seq.index $t@9 i@24)) i@24))
:pattern (($Seq.index $t@9 i@24)))))
(assert (forall ((i@24 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@24)
(not (= ($Seq.index $t@9 i@24) $Ref.null)))
:pattern (($Seq.index $t@9 i@24)))))
(assert (forall ((i@24 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@24)
($Set.in ($Seq.index $t@9 i@24) ($FVF.domain_value $t@23)))
:pattern (($FVF.lookup_value $t@23 ($Seq.index $t@9 i@24))))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))) && (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))))
(declare-const i@26 Int)
(push) ; 3
; [eval] (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 4
(set-option :timeout 0)
(declare-const grd@27 Bool)
(assert (implies grd@27 (not (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)))))
(check-sat grd@27)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@28 Bool)
(assert (implies grd@28 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))))
(check-sat grd@28)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 5
; [then-branch 1] i@26 in [0..|$t@9|]
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
; [eval] ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])
; [eval] i + 1 < |this.nodes|
; [eval] i + 1
; [eval] |this.nodes|
(push) ; 6
(set-option :timeout 0)
(declare-const grd@29 Bool)
(assert (implies grd@29 (not (not (< (+ i@26 1) ($Seq.length $t@9))))))
(check-sat grd@29)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@30 Bool)
(assert (implies grd@30 (not (< (+ i@26 1) ($Seq.length $t@9)))))
(check-sat grd@30)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 7
; [then-branch 2] i@26 + 1 < |$t@9|
(assert (< (+ i@26 1) ($Seq.length $t@9)))
; [eval] this.nodes[i].next == this.nodes[i + 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@31 Bool)
(assert (implies grd@31 (not (not (= ($Seq.index $t@9 i@26) $Ref.null)))))
(check-sat grd@31)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@32 Bool)
(assert (implies grd@32 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@18 ($Seq.index $t@9 i@26))))))
(check-sat grd@32)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@33 $FVF<$Ref>)
(assert (forall ((i@26 Int)) (!
true
)))
; [eval] this.nodes[i + 1]
; [eval] i + 1
(pop) ; 7
(push) ; 7
; [else-branch 2] !i@26 + 1 < |$t@9|
(assert (not (< (+ i@26 1) ($Seq.length $t@9))))
(pop) ; 7
(pop) ; 6
(assert (forall ((i@26 Int)) (!
true
)))
(push) ; 6
(set-option :timeout 0)
(declare-const grd@34 Bool)
(assert (implies grd@34 (not (not
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))))))
(check-sat grd@34)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@35 Bool)
(assert (implies grd@35 (not (implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1)))))))
(check-sat grd@35)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 7
; [then-branch 3] i@26 + 1 < |$t@9| ==> Lookup(next,$t@15,$t@9[i@26]) == $t@9[i@26 + 1]
(assert (implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1)))))
; [eval] ((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))
; [eval] (0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])
; [eval] 0 < i
(push) ; 8
(set-option :timeout 0)
(declare-const grd@36 Bool)
(assert (implies grd@36 (not (not (< 0 i@26)))))
(check-sat grd@36)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@37 Bool)
(assert (implies grd@37 (not (< 0 i@26))))
(check-sat grd@37)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 9
; [then-branch 4] 0 < i@26
(assert (< 0 i@26))
; [eval] this.nodes[i].prev == this.nodes[i - 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@38 Bool)
(assert (implies grd@38 (not (not (= ($Seq.index $t@9 i@26) $Ref.null)))))
(check-sat grd@38)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@39 Bool)
(assert (implies grd@39 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@22 ($Seq.index $t@9 i@26))))))
(check-sat grd@39)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@40 $FVF<$Ref>)
; [eval] this.nodes[i - 1]
; [eval] i - 1
(pop) ; 9
(push) ; 9
; [else-branch 4] !0 < i@26
(assert (not (< 0 i@26)))
(pop) ; 9
(pop) ; 8
(push) ; 8
(set-option :timeout 0)
(declare-const grd@41 Bool)
(assert (implies grd@41 (not (not
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))))))
(check-sat grd@41)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@42 Bool)
(assert (implies grd@42 (not (implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1)))))))
(check-sat grd@42)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 9
; [then-branch 5] 0 < i@26 ==> Lookup(prev,$t@19,$t@9[i@26]) == $t@9[i@26 - 1]
(assert (implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1)))))
; [eval] (this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])
; [eval] this.nodes[0].prev == this.nodes[|this.nodes| - 1]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@43 Bool)
(assert (implies grd@43 (not (not (= ($Seq.index $t@9 0) $Ref.null)))))
(check-sat grd@43)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@44 Bool)
(assert (implies grd@44 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) (inv@22 ($Seq.index $t@9 0))))))
(check-sat grd@44)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@45 $FVF<$Ref>)
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(push) ; 10
(set-option :timeout 0)
(declare-const grd@46 Bool)
(assert (implies grd@46 (not (not
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))))))
(check-sat grd@46)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@47 Bool)
(assert (implies grd@47 (not (=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1))))))
(check-sat grd@47)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 11
; [then-branch 6] Lookup(prev,$t@19,$t@9[0]) == $t@9[|$t@9| - 1]
(assert (=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1))))
; [eval] this.nodes[|this.nodes| - 1].next == this.nodes[0]
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@48 Bool)
(assert (implies grd@48 (not (not (= ($Seq.index $t@9 (- ($Seq.length $t@9) 1)) $Ref.null)))))
(check-sat grd@48)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@49 Bool)
(assert (implies grd@49 (not ($Seq.contains
($Seq.range 0 ($Seq.length $t@9))
(inv@18 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))))))
(check-sat grd@49)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@50 $FVF<$Ref>)
; [eval] this.nodes[0]
(pop) ; 11
(push) ; 11
; [else-branch 6] Lookup(prev,$t@19,$t@9[0]) != $t@9[|$t@9| - 1]
(assert (not
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))))
(pop) ; 11
(pop) ; 10
(pop) ; 9
(push) ; 9
; [else-branch 5] !0 < i@26 ==> Lookup(prev,$t@19,$t@9[i@26]) == $t@9[i@26 - 1]
(assert (not
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))))
(pop) ; 9
(pop) ; 8
(pop) ; 7
(push) ; 7
; [else-branch 3] !i@26 + 1 < |$t@9| ==> Lookup(next,$t@15,$t@9[i@26]) == $t@9[i@26 + 1]
(assert (not
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))))
(pop) ; 7
(pop) ; 6
(pop) ; 5
(push) ; 5
; [else-branch 1] !i@26 in [0..|$t@9|]
(assert (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)))
(pop) ; 5
(pop) ; 4
(assert (forall ((i@26 Int)) (!
true
)))
(pop) ; 3
(assert (forall ((i@26 Int)) (!
true
)))
(push) ; 3
(set-option :timeout 0)
(declare-const grd@51 Bool)
(assert (implies grd@51 (not (not
(forall ((i@26 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)
(and
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))
(and
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))
(and
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
($Seq.index $t@9 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
:pattern (($Seq.index $t@9 i@26))
:pattern (($Seq.index $t@9 i@26))))))))
(check-sat grd@51)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@52 Bool)
(assert (implies grd@52 (not (forall ((i@26 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)
(and
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))
(and
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))
(and
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
($Seq.index $t@9 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
:pattern (($Seq.index $t@9 i@26))
:pattern (($Seq.index $t@9 i@26)))))))
(check-sat grd@52)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 4
; [then-branch 7] QA i@26 :: i@26 in [0..|$t@9|] ==> i@26 + 1 < |$t@9| ==> Lookup(next,$t@15,$t@9[i@26]) == $t@9[i@26 + 1] && 0 < i@26 ==> Lookup(prev,$t@19,$t@9[i@26]) == $t@9[i@26 - 1] && Lookup(prev,$t@19,$t@9[0]) == $t@9[|$t@9| - 1] && Lookup(next,$t@15,$t@9[|$t@9| - 1]) == $t@9[0]
(assert (forall ((i@26 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)
(and
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))
(and
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))
(and
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
($Seq.index $t@9 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
:pattern (($Seq.index $t@9 i@26))
:pattern (($Seq.index $t@9 i@26)))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
(declare-const i@53 Int)
(push) ; 5
; [eval] (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 6
(set-option :timeout 0)
(declare-const grd@54 Bool)
(assert (implies grd@54 (not (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53)))))
(check-sat grd@54)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@55 Bool)
(assert (implies grd@55 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53))))
(check-sat grd@55)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 7
; [then-branch 8] i@53 in [0..|$t@9|]
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53))
; [eval] !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (this.nodes[i] in this.nodes[i + 1..])
; [eval] this.nodes[i + 1..]
; [eval] i + 1
; [eval] this.nodes[i]
(pop) ; 7
(push) ; 7
; [else-branch 8] !i@53 in [0..|$t@9|]
(assert (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53)))
(pop) ; 7
(pop) ; 6
(pop) ; 5
(pop) ; 4
(push) ; 4
; [else-branch 7] !QA i@26 :: i@26 in [0..|$t@9|] ==> i@26 + 1 < |$t@9| ==> Lookup(next,$t@15,$t@9[i@26]) == $t@9[i@26 + 1] && 0 < i@26 ==> Lookup(prev,$t@19,$t@9[i@26]) == $t@9[i@26 - 1] && Lookup(prev,$t@19,$t@9[0]) == $t@9[|$t@9| - 1] && Lookup(next,$t@15,$t@9[|$t@9| - 1]) == $t@9[0]
(assert (not
(forall ((i@26 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)
(and
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))
(and
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))
(and
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
($Seq.index $t@9 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
:pattern (($Seq.index $t@9 i@26))
:pattern (($Seq.index $t@9 i@26))))))
(pop) ; 4
(pop) ; 3
(assert (and
(forall ((i@26 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26)
(and
(implies
(< (+ i@26 1) ($Seq.length $t@9))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (+ i@26 1))))
(and
(implies
(< 0 i@26)
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 i@26))
($Seq.index $t@9 (- i@26 1))))
(and
(=
($FVF.lookup_prev $t@19 ($Seq.index $t@9 0))
($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
(=
($FVF.lookup_next $t@15 ($Seq.index $t@9 (- ($Seq.length $t@9) 1)))
($Seq.index $t@9 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@26))
:pattern (($Seq.index $t@9 i@26))
:pattern (($Seq.index $t@9 i@26))))
(forall ((i@53 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53)
(not ($Seq.contains ($Seq.drop $t@9 (+ i@53 1)) ($Seq.index $t@9 i@53))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@9)) i@53))))))
; [eval] (n in this.nodes)
(assert ($Seq.contains $t@9 n@3))
(push) ; 3
(declare-const $t@56 $Snap)
(pop) ; 3
(push) ; 3
; [exec]
; newNode := new(header, nodes, next, prev, value)
(declare-const newNode@57 $Ref)
(assert (not (= newNode@57 $Ref.null)))
(declare-const header@58 $Ref)
(declare-const nodes@59 $Seq<$Ref>)
(declare-const next@60 $Ref)
(declare-const prev@61 $Ref)
(declare-const value@62 Int)
(assert (and
(not (= this@1 newNode@57))
(not (= n@3 newNode@57))
(not (= header@58 newNode@57))
(not (= next@60 newNode@57))
(not (= prev@61 newNode@57))))
; [exec]
; newNode.value := i
; [exec]
; newNode.next := n
; [exec]
; unfold acc(Valid(this), write)
(declare-const $t@63 $Ref)
(declare-const $t@64 $Snap)
(assert (= $t@6 ($Snap.combine ($SortWrappers.$RefTo$Snap $t@63) $t@64)))
(set-option :timeout 0)
(declare-const grd@65 Bool)
(assert (implies grd@65 (not (= newNode@57 this@1))))
(check-sat grd@65)
; unknown
; 0.00s
(get-info :all-statistics)
(declare-const $t@66 $Seq<$Ref>)
(declare-const $t@67 $Snap)
(assert (= $t@64 ($Snap.combine ($SortWrappers.$Seq<$Ref>To$Snap $t@66) $t@67)))
(set-option :timeout 0)
(declare-const grd@68 Bool)
(assert (implies grd@68 (not (= newNode@57 this@1))))
(check-sat grd@68)
; unknown
; 0.00s
(get-info :all-statistics)
(declare-const $t@69 $Snap)
(assert (= $t@67 ($Snap.combine $Snap.unit $t@69)))
; [eval] (this.header in this.nodes)
(assert ($Seq.contains $t@66 $t@63))
(declare-const $t@70 $Snap)
(assert (= $t@69 ($Snap.combine $Snap.unit $t@70)))
; [eval] !(null in this.nodes)
; [eval] (null in this.nodes)
(assert (not ($Seq.contains $t@66 $Ref.null)))
(declare-const $t@71 $Snap)
(assert (= $t@70 ($Snap.combine $Snap.unit $t@71)))
; [eval] 0 < |this.nodes|
; [eval] |this.nodes|
(assert (< 0 ($Seq.length $t@66)))
(declare-const $t@72 $Snap)
(assert (= $t@71 ($Snap.combine $Snap.unit $t@72)))
; [eval] this.header == this.nodes[0]
; [eval] this.nodes[0]
(assert (= $t@63 ($Seq.index $t@66 0)))
(declare-const $t@73 $FVF<$Ref>)
(declare-const $t@74 $Snap)
(assert (= $t@72 ($Snap.combine ($SortWrappers.$FVF<$Ref>To$Snap $t@73) $t@74)))
(declare-const i@75 Int)
(push) ; 4
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@75))
; [eval] this.nodes[i]
(pop) ; 4
(declare-fun inv@76 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
(= ($Seq.index $t@66 (inv@76 $r)) $r))
:pattern (($Seq.index $t@66 (inv@76 $r))))))
(assert (forall ((i@75 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@75)
(= (inv@76 ($Seq.index $t@66 i@75)) i@75))
:pattern (($Seq.index $t@66 i@75)))))
(assert (forall ((i@75 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@75)
(not (= ($Seq.index $t@66 i@75) $Ref.null)))
:pattern (($Seq.index $t@66 i@75)))))
(assert (forall ((i@75 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@75)
($Set.in ($Seq.index $t@66 i@75) ($FVF.domain_next $t@73)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index $t@66 i@75))))))
(declare-const fvf@77 $FVF<$Ref>)
(assert (and
(= ($FVF.lookup_next fvf@77 newNode@57) n@3)
($Set.equal ($FVF.domain_next fvf@77) ($Set.singleton newNode@57))))
(declare-const $t@78 $FVF<$Ref>)
(declare-const $t@79 $FVF<Int>)
(assert (=
$t@74
($Snap.combine
($SortWrappers.$FVF<$Ref>To$Snap $t@78)
($SortWrappers.$FVF<Int>To$Snap $t@79))))
(declare-const i@80 Int)
(push) ; 4
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@80))
; [eval] this.nodes[i]
(pop) ; 4
(declare-fun inv@81 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
(= ($Seq.index $t@66 (inv@81 $r)) $r))
:pattern (($Seq.index $t@66 (inv@81 $r))))))
(assert (forall ((i@80 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@80)
(= (inv@81 ($Seq.index $t@66 i@80)) i@80))
:pattern (($Seq.index $t@66 i@80)))))
(assert (forall ((i@80 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@80)
(not (= ($Seq.index $t@66 i@80) $Ref.null)))
:pattern (($Seq.index $t@66 i@80)))))
(assert (forall ((i@80 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@80)
($Set.in ($Seq.index $t@66 i@80) ($FVF.domain_prev $t@78)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@80))))))
(declare-const fvf@82 $FVF<$Ref>)
(assert (and
(= ($FVF.lookup_prev fvf@82 newNode@57) prev@61)
($Set.equal ($FVF.domain_prev fvf@82) ($Set.singleton newNode@57))))
(declare-const $t@83 $FVF<Int>)
(assert (=
($SortWrappers.$FVF<Int>To$Snap $t@79)
($Snap.combine ($SortWrappers.$FVF<Int>To$Snap $t@83) $Snap.unit)))
(declare-const i@84 Int)
(push) ; 4
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@84))
; [eval] this.nodes[i]
(pop) ; 4
(declare-fun inv@85 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@85 $r))
(= ($Seq.index $t@66 (inv@85 $r)) $r))
:pattern (($Seq.index $t@66 (inv@85 $r))))))
(assert (forall ((i@84 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@84)
(= (inv@85 ($Seq.index $t@66 i@84)) i@84))
:pattern (($Seq.index $t@66 i@84)))))
(assert (forall ((i@84 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@84)
(not (= ($Seq.index $t@66 i@84) $Ref.null)))
:pattern (($Seq.index $t@66 i@84)))))
(assert (forall ((i@84 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@84)
($Set.in ($Seq.index $t@66 i@84) ($FVF.domain_value $t@83)))
:pattern (($FVF.lookup_value $t@83 ($Seq.index $t@66 i@84))))))
(declare-const fvf@86 $FVF<Int>)
(assert (and
(= ($FVF.lookup_value fvf@86 newNode@57) i@2)
($Set.equal ($FVF.domain_value fvf@86) ($Set.singleton newNode@57))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))) && (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))))
(declare-const i@87 Int)
(push) ; 4
; [eval] (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 5
(set-option :timeout 0)
(declare-const grd@88 Bool)
(assert (implies grd@88 (not (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)))))
(check-sat grd@88)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@89 Bool)
(assert (implies grd@89 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))))
(check-sat grd@89)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 6
; [then-branch 9] i@87 in [0..|$t@66|]
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))
; [eval] ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])
; [eval] i + 1 < |this.nodes|
; [eval] i + 1
; [eval] |this.nodes|
(push) ; 7
(set-option :timeout 0)
(declare-const grd@90 Bool)
(assert (implies grd@90 (not (not (< (+ i@87 1) ($Seq.length $t@66))))))
(check-sat grd@90)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@91 Bool)
(assert (implies grd@91 (not (< (+ i@87 1) ($Seq.length $t@66)))))
(check-sat grd@91)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 8
; [then-branch 10] i@87 + 1 < |$t@66|
(assert (< (+ i@87 1) ($Seq.length $t@66)))
; [eval] this.nodes[i].next == this.nodes[i + 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@92 Bool)
(assert (implies grd@92 (not (not (= ($Seq.index $t@66 i@87) $Ref.null)))))
(check-sat grd@92)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@93 Bool)
(assert (implies grd@93 (not (<
$Perm.No
(+
(ite (= ($Seq.index $t@66 i@87) newNode@57) $Perm.Write $Perm.No)
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 i@87)))
$Perm.Write
$Perm.No))))))
(check-sat grd@93)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@94 $FVF<$Ref>)
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))))
(assert ($Set.equal
($FVF.domain_next fvf@94)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
; [eval] this.nodes[i + 1]
; [eval] i + 1
(pop) ; 8
(push) ; 8
; [else-branch 10] !i@87 + 1 < |$t@66|
(assert (not (< (+ i@87 1) ($Seq.length $t@66))))
(pop) ; 8
(pop) ; 7
(assert ($Set.equal
($FVF.domain_next fvf@94)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))))
(push) ; 7
(set-option :timeout 0)
(declare-const grd@95 Bool)
(assert (implies grd@95 (not (not
(implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1))))))))
(check-sat grd@95)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@96 Bool)
(assert (implies grd@96 (not (implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1)))))))
(check-sat grd@96)
; unsat
; 0.00s
(get-info :all-statistics)
(push) ; 8
; [then-branch 11] i@87 + 1 < |$t@66| ==> Lookup(next,fvf@94,$t@66[i@87]) == $t@66[i@87 + 1]
(assert (implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1)))))
; [eval] ((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))
; [eval] (0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])
; [eval] 0 < i
(push) ; 9
(set-option :timeout 0)
(declare-const grd@97 Bool)
(assert (implies grd@97 (not (not (< 0 i@87)))))
(check-sat grd@97)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@98 Bool)
(assert (implies grd@98 (not (< 0 i@87))))
(check-sat grd@98)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 10
; [then-branch 12] 0 < i@87
(assert (< 0 i@87))
; [eval] this.nodes[i].prev == this.nodes[i - 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@99 Bool)
(assert (implies grd@99 (not (not (= ($Seq.index $t@66 i@87) $Ref.null)))))
(check-sat grd@99)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@100 Bool)
(assert (implies grd@100 (not (<
$Perm.No
(+
(ite (= ($Seq.index $t@66 i@87) newNode@57) $Perm.Write $Perm.No)
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
$Perm.Write
$Perm.No))))))
(check-sat grd@100)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@101 $FVF<$Ref>)
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))))
(assert ($Set.equal
($FVF.domain_prev fvf@101)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
; [eval] this.nodes[i - 1]
; [eval] i - 1
(pop) ; 10
(push) ; 10
; [else-branch 12] !0 < i@87
(assert (not (< 0 i@87)))
(pop) ; 10
(pop) ; 9
(assert ($Set.equal
($FVF.domain_prev fvf@101)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))))
(push) ; 9
(set-option :timeout 0)
(declare-const grd@102 Bool)
(assert (implies grd@102 (not (not
(implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1))))))))
(check-sat grd@102)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@103 Bool)
(assert (implies grd@103 (not (implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1)))))))
(check-sat grd@103)
; unsat
; 0.00s
(get-info :all-statistics)
(push) ; 10
; [then-branch 13] 0 < i@87 ==> Lookup(prev,fvf@101,$t@66[i@87]) == $t@66[i@87 - 1]
(assert (implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1)))))
; [eval] (this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])
; [eval] this.nodes[0].prev == this.nodes[|this.nodes| - 1]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@104 Bool)
(assert (implies grd@104 (not (not (= ($Seq.index $t@66 0) $Ref.null)))))
(check-sat grd@104)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@105 Bool)
(assert (implies grd@105 (not (<
$Perm.No
(+
(ite (= ($Seq.index $t@66 0) newNode@57) $Perm.Write $Perm.No)
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
$Perm.Write
$Perm.No))))))
(check-sat grd@105)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@106 $FVF<$Ref>)
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 0)))))
(assert (implies
(= ($Seq.index $t@66 0) newNode@57)
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@106)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(push) ; 11
(set-option :timeout 0)
(declare-const grd@107 Bool)
(assert (implies grd@107 (not (not
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1)))))))
(check-sat grd@107)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@108 Bool)
(assert (implies grd@108 (not (=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(check-sat grd@108)
; unsat
; 0.06s
(get-info :all-statistics)
(push) ; 12
; [then-branch 14] Lookup(prev,fvf@106,$t@66[0]) == $t@66[|$t@66| - 1]
(assert (=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
; [eval] this.nodes[|this.nodes| - 1].next == this.nodes[0]
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@109 Bool)
(assert (implies grd@109 (not (not (= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) $Ref.null)))))
(check-sat grd@109)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@110 Bool)
(assert (implies grd@110 (not (<
$Perm.No
(+
(ite
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
$Perm.Write
$Perm.No)
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
$Perm.Write
$Perm.No))))))
(check-sat grd@110)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@111 $FVF<$Ref>)
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
; [eval] this.nodes[0]
(pop) ; 12
; [dead else-branch 14] Lookup(prev,fvf@106,$t@66[0]) != $t@66[|$t@66| - 1]
(pop) ; 11
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(pop) ; 10
; [dead else-branch 13] !0 < i@87 ==> Lookup(prev,fvf@101,$t@66[i@87]) == $t@66[i@87 - 1]
(pop) ; 9
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@106)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (implies
(= ($Seq.index $t@66 0) newNode@57)
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 0)))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 0)))))
(pop) ; 8
; [dead else-branch 11] !i@87 + 1 < |$t@66| ==> Lookup(next,fvf@94,$t@66[i@87]) == $t@66[i@87 + 1]
(pop) ; 7
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 0)))))
(assert (implies
(= ($Seq.index $t@66 0) newNode@57)
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@106)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))))
(assert ($Set.equal
($FVF.domain_prev fvf@101)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(pop) ; 6
(push) ; 6
; [else-branch 9] !i@87 in [0..|$t@66|]
(assert (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)))
(pop) ; 6
(pop) ; 5
(assert ($Set.equal
($FVF.domain_prev fvf@101)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@106)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (implies
(= ($Seq.index $t@66 0) newNode@57)
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 0)))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 0)))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))))
(assert ($Set.equal
($FVF.domain_next fvf@94)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(pop) ; 4
(assert ($Set.equal
($FVF.domain_prev fvf@101)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev fvf@82 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index $t@66 i@87))))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next $t@73 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert (implies
(= ($Seq.index $t@66 (- ($Seq.length $t@66) 1)) newNode@57)
(=
($FVF.lookup_next fvf@111 ($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 (- ($Seq.length $t@66) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@111)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@106)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(assert (implies
(= ($Seq.index $t@66 0) newNode@57)
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev fvf@82 ($Seq.index $t@66 0)))))
(assert (implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index $t@66 0)))
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($FVF.lookup_prev $t@78 ($Seq.index $t@66 0)))))
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index $t@66 i@87)))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index $t@66 i@87))))))
(assert (forall ((i@87 Int)) (!
(implies
(= ($Seq.index $t@66 i@87) newNode@57)
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))
:pattern (($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index $t@66 i@87))))))
(assert ($Set.equal
($FVF.domain_next fvf@94)
($Set.union ($FVF.domain_next fvf@77) ($FVF.domain_next $t@73))))
(push) ; 4
(set-option :timeout 0)
(declare-const grd@112 Bool)
(assert (implies grd@112 (not (not
(forall ((i@87 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)
(and
(implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1))))
(and
(implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1))))
(and
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
(=
($FVF.lookup_next fvf@111 ($Seq.index
$t@66
(- ($Seq.length $t@66) 1)))
($Seq.index $t@66 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))
:pattern (($Seq.index $t@66 i@87))
:pattern (($Seq.index $t@66 i@87))))))))
(check-sat grd@112)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@113 Bool)
(assert (implies grd@113 (not (forall ((i@87 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)
(and
(implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1))))
(and
(implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1))))
(and
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
(=
($FVF.lookup_next fvf@111 ($Seq.index
$t@66
(- ($Seq.length $t@66) 1)))
($Seq.index $t@66 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))
:pattern (($Seq.index $t@66 i@87))
:pattern (($Seq.index $t@66 i@87)))))))
(check-sat grd@113)
; unsat
; 0.00s
(get-info :all-statistics)
(push) ; 5
; [then-branch 15] QA i@87 :: i@87 in [0..|$t@66|] ==> i@87 + 1 < |$t@66| ==> Lookup(next,fvf@94,$t@66[i@87]) == $t@66[i@87 + 1] && 0 < i@87 ==> Lookup(prev,fvf@101,$t@66[i@87]) == $t@66[i@87 - 1] && Lookup(prev,fvf@106,$t@66[0]) == $t@66[|$t@66| - 1] && Lookup(next,fvf@111,$t@66[|$t@66| - 1]) == $t@66[0]
(assert (forall ((i@87 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)
(and
(implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1))))
(and
(implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1))))
(and
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
(=
($FVF.lookup_next fvf@111 ($Seq.index
$t@66
(- ($Seq.length $t@66) 1)))
($Seq.index $t@66 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))
:pattern (($Seq.index $t@66 i@87))
:pattern (($Seq.index $t@66 i@87)))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
(declare-const i@114 Int)
(push) ; 6
; [eval] (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 7
(set-option :timeout 0)
(declare-const grd@115 Bool)
(assert (implies grd@115 (not (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114)))))
(check-sat grd@115)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@116 Bool)
(assert (implies grd@116 (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114))))
(check-sat grd@116)
; unknown
; 0.00s
(get-info :all-statistics)
(push) ; 8
; [then-branch 16] i@114 in [0..|$t@66|]
(assert ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114))
; [eval] !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (this.nodes[i] in this.nodes[i + 1..])
; [eval] this.nodes[i + 1..]
; [eval] i + 1
; [eval] this.nodes[i]
(pop) ; 8
(push) ; 8
; [else-branch 16] !i@114 in [0..|$t@66|]
(assert (not ($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114)))
(pop) ; 8
(pop) ; 7
(pop) ; 6
(pop) ; 5
; [dead else-branch 15] !QA i@87 :: i@87 in [0..|$t@66|] ==> i@87 + 1 < |$t@66| ==> Lookup(next,fvf@94,$t@66[i@87]) == $t@66[i@87 + 1] && 0 < i@87 ==> Lookup(prev,fvf@101,$t@66[i@87]) == $t@66[i@87 - 1] && Lookup(prev,fvf@106,$t@66[0]) == $t@66[|$t@66| - 1] && Lookup(next,fvf@111,$t@66[|$t@66| - 1]) == $t@66[0]
(pop) ; 4
(assert (and
(forall ((i@87 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87)
(and
(implies
(< (+ i@87 1) ($Seq.length $t@66))
(=
($FVF.lookup_next fvf@94 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (+ i@87 1))))
(and
(implies
(< 0 i@87)
(=
($FVF.lookup_prev fvf@101 ($Seq.index $t@66 i@87))
($Seq.index $t@66 (- i@87 1))))
(and
(=
($FVF.lookup_prev fvf@106 ($Seq.index $t@66 0))
($Seq.index $t@66 (- ($Seq.length $t@66) 1)))
(=
($FVF.lookup_next fvf@111 ($Seq.index
$t@66
(- ($Seq.length $t@66) 1)))
($Seq.index $t@66 0))))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@87))
:pattern (($Seq.index $t@66 i@87))
:pattern (($Seq.index $t@66 i@87))))
(forall ((i@114 Int)) (!
(implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114)
(not
($Seq.contains ($Seq.drop $t@66 (+ i@114 1)) ($Seq.index $t@66 i@114))))
:pattern (($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) i@114))))))
; [exec]
; newNode.prev := n.prev
(set-option :timeout 0)
(declare-const grd@117 Bool)
(assert (implies grd@117 (not (not (= n@3 $Ref.null)))))
(check-sat grd@117)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@118 Bool)
(assert (implies grd@118 (not (<
$Perm.No
(+
(ite (= n@3 newNode@57) $Perm.Write $Perm.No)
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 n@3))
$Perm.Write
$Perm.No))))))
(check-sat grd@118)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@119 $FVF<$Ref>)
(assert (implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 n@3))
(= ($FVF.lookup_prev fvf@119 n@3) ($FVF.lookup_prev $t@78 n@3))))
(assert (implies
(= n@3 newNode@57)
(= ($FVF.lookup_prev fvf@119 n@3) ($FVF.lookup_prev fvf@82 n@3))))
(assert ($Set.equal
($FVF.domain_prev fvf@119)
($Set.union ($FVF.domain_prev fvf@82) ($FVF.domain_prev $t@78))))
(declare-const fvf@120 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@121 Bool)
(assert (implies grd@121 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r newNode@57) $Perm.Write $Perm.No)
(ite
(= $r newNode@57)
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@121)
; unsat
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@122 Bool)
(assert (implies grd@122 (not (= (- $Perm.Write ($Perm.min $Perm.Write $Perm.Write)) $Perm.No))))
(check-sat grd@122)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@123 $FVF<$Ref>)
(assert (and
(= ($FVF.lookup_prev fvf@123 newNode@57) ($FVF.lookup_prev fvf@119 n@3))
($Set.equal ($FVF.domain_prev fvf@123) ($Set.singleton newNode@57))))
; [exec]
; newNode.prev.next := newNode
(set-option :timeout 0)
(declare-const grd@124 Bool)
(assert (implies grd@124 (not (<
$Perm.No
(+
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 newNode@57))
$Perm.Write
$Perm.No)
$Perm.Write)))))
(check-sat grd@124)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@125 $FVF<$Ref>)
(assert (= ($FVF.lookup_prev fvf@125 newNode@57) ($FVF.lookup_prev fvf@123 newNode@57)))
(assert (implies
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 newNode@57))
(= ($FVF.lookup_prev fvf@125 newNode@57) ($FVF.lookup_prev $t@78 newNode@57))))
(assert ($Set.equal
($FVF.domain_prev fvf@125)
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))))
(set-option :timeout 0)
(declare-const grd@126 Bool)
(assert (implies grd@126 (not (not (= ($FVF.lookup_prev fvf@125 newNode@57) $Ref.null)))))
(check-sat grd@126)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@127 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@128 Bool)
(assert (implies grd@128 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@128)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@129 Bool)
(assert (implies grd@129 (not (=
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_prev fvf@125 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@129)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@130 Bool)
(assert (implies grd@130 (not (forall (($r $Ref)) (!
(=
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@130)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@131 Bool)
(assert (implies grd@131 (not (=
(-
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_prev fvf@125 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
($Perm.min
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_prev fvf@125 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($FVF.lookup_prev fvf@125 newNode@57)))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@131)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@132 $FVF<$Ref>)
(assert (and
(= ($FVF.lookup_next fvf@132 ($FVF.lookup_prev fvf@125 newNode@57)) newNode@57)
($Set.equal
($FVF.domain_next fvf@132)
($Set.singleton ($FVF.lookup_prev fvf@125 newNode@57)))))
; [exec]
; newNode.next.prev := newNode
(set-option :timeout 0)
(declare-const grd@133 Bool)
(assert (implies grd@133 (not (<
$Perm.No
(+
(+
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)))
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 newNode@57))
$Perm.Write
$Perm.No)
$Perm.No)))
(-
$Perm.Write
($Perm.min
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No))))
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No))))))
(check-sat grd@133)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@134 $FVF<$Ref>)
(assert (implies
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
(= ($FVF.lookup_next fvf@134 newNode@57) ($FVF.lookup_next fvf@132 newNode@57))))
(assert (implies
(<
$Perm.No
(-
$Perm.Write
($Perm.min
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No))))
(= ($FVF.lookup_next fvf@134 newNode@57) ($FVF.lookup_next fvf@77 newNode@57))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)))
(ite
(= newNode@57 ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 newNode@57))
$Perm.Write
$Perm.No)
$Perm.No))))
(= ($FVF.lookup_next fvf@134 newNode@57) ($FVF.lookup_next $t@73 newNode@57))))
(assert ($Set.equal
($FVF.domain_next fvf@134)
($Set.union
($Set.union ($FVF.domain_next $t@73) ($FVF.domain_next fvf@77))
($FVF.domain_next fvf@132))))
(set-option :timeout 0)
(declare-const grd@135 Bool)
(assert (implies grd@135 (not (not (= ($FVF.lookup_next fvf@134 newNode@57) $Ref.null)))))
(check-sat grd@135)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@136 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@137 Bool)
(assert (implies grd@137 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@137)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@138 Bool)
(assert (implies grd@138 (not (=
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_next fvf@134 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@138)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@139 Bool)
(assert (implies grd@139 (not (forall (($r $Ref)) (!
(=
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@139)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@140 Bool)
(assert (implies grd@140 (not (=
(-
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_next fvf@134 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
($Perm.min
(-
$Perm.Write
($Perm.min
$Perm.Write
(ite
(= ($FVF.lookup_next fvf@134 newNode@57) newNode@57)
$Perm.Write
$Perm.No)))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($FVF.lookup_next fvf@134 newNode@57)))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@140)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@141 $FVF<$Ref>)
(assert (and
(= ($FVF.lookup_prev fvf@141 ($FVF.lookup_next fvf@134 newNode@57)) newNode@57)
($Set.equal
($FVF.domain_prev fvf@141)
($Set.singleton ($FVF.lookup_next fvf@134 newNode@57)))))
; [exec]
; inhale (0 <= index) && ((index < |this.nodes|) && (this.nodes[index] == n))
; [eval] (0 <= index) && ((index < |this.nodes|) && (this.nodes[index] == n))
; [eval] 0 <= index
(push) ; 4
(set-option :timeout 0)
(declare-const grd@142 Bool)
(assert (implies grd@142 (not (not (<= 0 index@5)))))
(check-sat grd@142)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@143 Bool)
(assert (implies grd@143 (not (<= 0 index@5))))
(check-sat grd@143)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 5
; [then-branch 17] 0 <= index@5
(assert (<= 0 index@5))
; [eval] (index < |this.nodes|) && (this.nodes[index] == n)
; [eval] index < |this.nodes|
; [eval] |this.nodes|
(push) ; 6
(set-option :timeout 0)
(declare-const grd@144 Bool)
(assert (implies grd@144 (not (not (< index@5 ($Seq.length $t@66))))))
(check-sat grd@144)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@145 Bool)
(assert (implies grd@145 (not (< index@5 ($Seq.length $t@66)))))
(check-sat grd@145)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 7
; [then-branch 18] index@5 < |$t@66|
(assert (< index@5 ($Seq.length $t@66)))
; [eval] this.nodes[index] == n
; [eval] this.nodes[index]
(pop) ; 7
(push) ; 7
; [else-branch 18] !index@5 < |$t@66|
(assert (not (< index@5 ($Seq.length $t@66))))
(pop) ; 7
(pop) ; 6
(pop) ; 5
(push) ; 5
; [else-branch 17] !0 <= index@5
(assert (not (<= 0 index@5)))
(pop) ; 5
(pop) ; 4
(assert (and
(<= 0 index@5)
(and (< index@5 ($Seq.length $t@66)) (= ($Seq.index $t@66 index@5) n@3))))
; [eval] index == 0
(set-option :timeout 0)
(declare-const grd@146 Bool)
(assert (implies grd@146 (not (not (= index@5 0)))))
(check-sat grd@146)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@147 Bool)
(assert (implies grd@147 (not (= index@5 0))))
(check-sat grd@147)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 4
; [then-branch 19] index@5 == 0
(assert (= index@5 0))
; [exec]
; this.nodes := this.nodes ++ Seq(newNode)
; [eval] this.nodes ++ Seq(newNode)
; [eval] Seq(newNode)
(assert (= ($Seq.length ($Seq.singleton newNode@57)) 1))
; [exec]
; fold acc(Valid(this), write)
; [eval] (this.header in this.nodes)
(set-option :timeout 0)
(declare-const grd@148 Bool)
(assert (implies grd@148 (not ($Seq.contains ($Seq.append $t@66 ($Seq.singleton newNode@57)) $t@63))))
(check-sat grd@148)
; unsat
; 0.00s
(get-info :all-statistics)
(assert ($Seq.contains ($Seq.append $t@66 ($Seq.singleton newNode@57)) $t@63))
; [eval] !(null in this.nodes)
; [eval] (null in this.nodes)
(set-option :timeout 0)
(declare-const grd@149 Bool)
(assert (implies grd@149 (not (not ($Seq.contains ($Seq.append $t@66 ($Seq.singleton newNode@57)) $Ref.null)))))
(check-sat grd@149)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (not ($Seq.contains ($Seq.append $t@66 ($Seq.singleton newNode@57)) $Ref.null)))
; [eval] 0 < |this.nodes|
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@150 Bool)
(assert (implies grd@150 (not (< 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))))))
(check-sat grd@150)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (< 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))))
; [eval] this.header == this.nodes[0]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@151 Bool)
(assert (implies grd@151 (not (= $t@63 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))))
(check-sat grd@151)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (= $t@63 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
(declare-const i@152 Int)
(declare-const fvf@153 $FVF<$Seq<$Ref>>)
(declare-const fvf@154 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@153 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@153) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@154 this@1)
($Seq.append $t@66 ($Seq.singleton newNode@57)))
($Set.equal ($FVF.domain_nodes fvf@154) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@155 Bool)
(assert (implies grd@155 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@155)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@156 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@156 this@1)
($FVF.lookup_nodes fvf@154 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@156 this@1)
($FVF.lookup_nodes fvf@153 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@156)
($Set.union ($FVF.domain_nodes fvf@153) ($FVF.domain_nodes fvf@154))))
(set-option :timeout 0)
(declare-const grd@157 Bool)
(assert (implies grd@157 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
i@152)))))
(check-sat grd@157)
; unknown
; 0.01s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
i@152))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@158 Bool)
(assert (implies grd@158 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@158)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@159 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@160 Bool)
(assert (implies grd@160 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@160)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-fun inv@161 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) (inv@161 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@156 this@1) (inv@161 $r))))))
(assert (forall ((i@152 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
i@152)
(= (inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)) i@152))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))))
(declare-const fvf@162 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@163 Bool)
(assert (implies grd@163 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@163)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@164 Bool)
(assert (implies grd@164 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@164)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@165 Bool)
(assert (implies grd@165 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@165)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@166 Bool)
(assert (implies grd@166 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@166)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@167 Bool)
(assert (implies grd@167 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range
0
($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152))
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@167)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@168 Bool)
(assert (implies grd@168 (not (=
(-
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@156 this@1)))
(inv@161 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@168)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (forall ((i@152 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))
($FVF.lookup_next $t@73 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))
:pattern (($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))))
(assert (forall ((i@152 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))
($FVF.lookup_next fvf@77 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))
:pattern (($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))))
(assert (forall ((i@152 Int)) (!
(implies
(=
($Seq.index ($FVF.lookup_nodes fvf@156 this@1) i@152)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))
($FVF.lookup_next fvf@132 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))
:pattern (($FVF.lookup_next fvf@162 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($FVF.lookup_nodes fvf@156 this@1)
i@152))))))
(assert ($Set.equal
($FVF.domain_next fvf@162)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(declare-const i@169 Int)
(declare-const fvf@170 $FVF<$Seq<$Ref>>)
(declare-const fvf@171 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@170 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@170) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@171 this@1)
($Seq.append $t@66 ($Seq.singleton newNode@57)))
($Set.equal ($FVF.domain_nodes fvf@171) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@172 Bool)
(assert (implies grd@172 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@172)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@173 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@173 this@1)
($FVF.lookup_nodes fvf@171 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@173 this@1)
($FVF.lookup_nodes fvf@170 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@173)
($Set.union ($FVF.domain_nodes fvf@170) ($FVF.domain_nodes fvf@171))))
(set-option :timeout 0)
(declare-const grd@174 Bool)
(assert (implies grd@174 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
i@169)))))
(check-sat grd@174)
; unknown
; 0.06s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
i@169))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@175 Bool)
(assert (implies grd@175 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@175)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@176 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@177 Bool)
(assert (implies grd@177 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@177)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-fun inv@178 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) (inv@178 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@173 this@1) (inv@178 $r))))))
(assert (forall ((i@169 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
i@169)
(= (inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)) i@169))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))))
(declare-const fvf@179 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@180 Bool)
(assert (implies grd@180 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@180)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@181 Bool)
(assert (implies grd@181 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@181)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@182 Bool)
(assert (implies grd@182 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@182)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@183 Bool)
(assert (implies grd@183 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@183)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@184 Bool)
(assert (implies grd@184 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range
0
($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169))
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@184)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@185 Bool)
(assert (implies grd@185 (not (=
(-
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@173 this@1)))
(inv@178 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@185)
; unsat
; 0.01s
(get-info :all-statistics)
(assert (forall ((i@169 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))
($FVF.lookup_prev $t@78 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))
:pattern (($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))))
(assert (forall ((i@169 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))
($FVF.lookup_prev fvf@123 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))
:pattern (($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))))
(assert (forall ((i@169 Int)) (!
(implies
(=
($Seq.index ($FVF.lookup_nodes fvf@173 this@1) i@169)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))
($FVF.lookup_prev fvf@141 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))
:pattern (($FVF.lookup_prev fvf@179 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($FVF.lookup_nodes fvf@173 this@1)
i@169))))))
(assert ($Set.equal
($FVF.domain_prev fvf@179)
($Set.union
($Set.union ($FVF.domain_prev fvf@141) ($FVF.domain_prev fvf@123))
($FVF.domain_prev $t@78))))
(declare-const i@186 Int)
(declare-const fvf@187 $FVF<$Seq<$Ref>>)
(declare-const fvf@188 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@187 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@187) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@188 this@1)
($Seq.append $t@66 ($Seq.singleton newNode@57)))
($Set.equal ($FVF.domain_nodes fvf@188) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@189 Bool)
(assert (implies grd@189 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@189)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@190 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@190 this@1)
($FVF.lookup_nodes fvf@188 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@190 this@1)
($FVF.lookup_nodes fvf@187 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@190)
($Set.union ($FVF.domain_nodes fvf@187) ($FVF.domain_nodes fvf@188))))
(set-option :timeout 0)
(declare-const grd@191 Bool)
(assert (implies grd@191 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
i@186)))))
(check-sat grd@191)
; unknown
; 0.10s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
i@186))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@192 Bool)
(assert (implies grd@192 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@192)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@193 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@194 Bool)
(assert (implies grd@194 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@194)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-fun inv@195 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) (inv@195 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@190 this@1) (inv@195 $r))))))
(assert (forall ((i@186 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
i@186)
(= (inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)) i@186))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))))
(declare-const fvf@196 $FVF<Int>)
(set-option :timeout 500)
(declare-const grd@197 Bool)
(assert (implies grd@197 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@197)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@198 Bool)
(assert (implies grd@198 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186) newNode@57)
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@198)
; unknown
; 0.00s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@199 Bool)
(assert (implies grd@199 (not (forall (($r $Ref)) (!
(=
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@85 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@85 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@199)
; unknown
; 0.04s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@200 Bool)
(assert (implies grd@200 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186) newNode@57)
$Perm.Write
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@190 this@1)))
(inv@195 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186) newNode@57)
$Perm.Write
$Perm.No)))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@85 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@200)
; unsat
; 0.03s
(get-info :all-statistics)
(assert (forall ((i@186 Int)) (!
(implies
(= ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186) newNode@57)
(=
($FVF.lookup_value fvf@196 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))
($FVF.lookup_value fvf@86 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))))
:pattern (($FVF.lookup_value fvf@196 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186)))
:pattern (($FVF.lookup_value fvf@86 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))))))
(assert (forall ((i@186 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@85 ($Seq.index ($FVF.lookup_nodes fvf@190 this@1) i@186)))
(=
($FVF.lookup_value fvf@196 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))
($FVF.lookup_value $t@83 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))))
:pattern (($FVF.lookup_value fvf@196 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186)))
:pattern (($FVF.lookup_value $t@83 ($Seq.index
($FVF.lookup_nodes fvf@190 this@1)
i@186))))))
(assert ($Set.equal
($FVF.domain_value fvf@196)
($Set.union ($FVF.domain_value $t@83) ($FVF.domain_value fvf@86))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))) && (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))))
(declare-const i@201 Int)
(push) ; 5
; [eval] (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 6
(set-option :timeout 0)
(declare-const grd@202 Bool)
(assert (implies grd@202 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)))))
(check-sat grd@202)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@203 Bool)
(assert (implies grd@203 (not ($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))))
(check-sat grd@203)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 7
; [then-branch 20] i@201 in [0..|$t@66 ++ [newNode@57]|]
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
; [eval] ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])
; [eval] i + 1 < |this.nodes|
; [eval] i + 1
; [eval] |this.nodes|
(push) ; 8
(set-option :timeout 0)
(declare-const grd@204 Bool)
(assert (implies grd@204 (not (not
(< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))))))
(check-sat grd@204)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@205 Bool)
(assert (implies grd@205 (not (< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))))))
(check-sat grd@205)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 9
; [then-branch 21] i@201 + 1 < |$t@66 ++ [newNode@57]|
(assert (< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))))
; [eval] this.nodes[i].next == this.nodes[i + 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@206 Bool)
(assert (implies grd@206 (not (not
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
$Ref.null)))))
(check-sat grd@206)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@207 Bool)
(assert (implies grd@207 (not (<
$Perm.No
(+
(+
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))))))
(check-sat grd@207)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@208 $FVF<$Ref>)
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert ($Set.equal
($FVF.domain_next fvf@208)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
; [eval] this.nodes[i + 1]
; [eval] i + 1
(pop) ; 9
(push) ; 9
; [else-branch 21] !i@201 + 1 < |$t@66 ++ [newNode@57]|
(assert (not
(< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))))
(pop) ; 9
(pop) ; 8
(assert ($Set.equal
($FVF.domain_next fvf@208)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(push) ; 8
(set-option :timeout 0)
(declare-const grd@209 Bool)
(assert (implies grd@209 (not (not
(implies
(< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (+ i@201 1))))))))
(check-sat grd@209)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@210 Bool)
(assert (implies grd@210 (not (implies
(< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (+ i@201 1)))))))
(check-sat grd@210)
; unsat
; 0.05s
(get-info :all-statistics)
(push) ; 9
; [then-branch 22] i@201 + 1 < |$t@66 ++ [newNode@57]| ==> Lookup(next,fvf@208,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 + 1]
(assert (implies
(< (+ i@201 1) ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (+ i@201 1)))))
; [eval] ((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))
; [eval] (0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])
; [eval] 0 < i
(push) ; 10
(set-option :timeout 0)
(declare-const grd@211 Bool)
(assert (implies grd@211 (not (not (< 0 i@201)))))
(check-sat grd@211)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@212 Bool)
(assert (implies grd@212 (not (< 0 i@201))))
(check-sat grd@212)
; unknown
; 0.02s
(get-info :all-statistics)
(push) ; 11
; [then-branch 23] 0 < i@201
(assert (< 0 i@201))
; [eval] this.nodes[i].prev == this.nodes[i - 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@213 Bool)
(assert (implies grd@213 (not (not
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
$Ref.null)))))
(check-sat grd@213)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@214 Bool)
(assert (implies grd@214 (not (<
$Perm.No
(+
(+
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No)))
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No))))))
(check-sat grd@214)
; unsat
; 0.02s
(get-info :all-statistics)
(declare-const fvf@215 $FVF<$Ref>)
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert ($Set.equal
($FVF.domain_prev fvf@215)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
; [eval] this.nodes[i - 1]
; [eval] i - 1
(pop) ; 11
(push) ; 11
; [else-branch 23] !0 < i@201
(assert (not (< 0 i@201)))
(pop) ; 11
(pop) ; 10
(assert ($Set.equal
($FVF.domain_prev fvf@215)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(push) ; 10
(set-option :timeout 0)
(declare-const grd@216 Bool)
(assert (implies grd@216 (not (not
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (- i@201 1))))))))
(check-sat grd@216)
; unknown
; 0.17s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@217 Bool)
(assert (implies grd@217 (not (implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (- i@201 1)))))))
(check-sat grd@217)
; unsat
; 0.01s
(get-info :all-statistics)
(push) ; 11
; [then-branch 24] 0 < i@201 ==> Lookup(prev,fvf@215,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 - 1]
(assert (implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) (- i@201 1)))))
; [eval] (this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])
; [eval] this.nodes[0].prev == this.nodes[|this.nodes| - 1]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@218 Bool)
(assert (implies grd@218 (not (not
(= ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0) $Ref.null)))))
(check-sat grd@218)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@219 Bool)
(assert (implies grd@219 (not (<
$Perm.No
(+
(+
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No)))
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No))))))
(check-sat grd@219)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@220 $FVF<$Ref>)
(assert (implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@220)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(push) ; 12
(set-option :timeout 0)
(declare-const grd@221 Bool)
(assert (implies grd@221 (not (not
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))))))
(check-sat grd@221)
; unknown
; 0.08s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@222 Bool)
(assert (implies grd@222 (not (=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(check-sat grd@222)
; unsat
; 0.00s
(get-info :all-statistics)
(push) ; 13
; [then-branch 25] Lookup(prev,fvf@220,$t@66 ++ [newNode@57][0]) == $t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1]
(assert (=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
; [eval] this.nodes[|this.nodes| - 1].next == this.nodes[0]
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@223 Bool)
(assert (implies grd@223 (not (not
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
$Ref.null)))))
(check-sat grd@223)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@224 Bool)
(assert (implies grd@224 (not (<
$Perm.No
(+
(+
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))))))
(check-sat grd@224)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@225 $FVF<$Ref>)
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
; [eval] this.nodes[0]
(pop) ; 13
; [dead else-branch 25] Lookup(prev,fvf@220,$t@66 ++ [newNode@57][0]) != $t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1]
(pop) ; 12
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(pop) ; 11
; [dead else-branch 24] !0 < i@201 ==> Lookup(prev,fvf@215,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 - 1]
(pop) ; 10
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@220)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(pop) ; 9
; [dead else-branch 22] !i@201 + 1 < |$t@66 ++ [newNode@57]| ==> Lookup(next,fvf@208,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 + 1]
(pop) ; 8
(assert (implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@220)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert ($Set.equal
($FVF.domain_prev fvf@215)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(pop) ; 7
(push) ; 7
; [else-branch 20] !i@201 in [0..|$t@66 ++ [newNode@57]|]
(assert (not
($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)))
(pop) ; 7
(pop) ; 6
(assert ($Set.equal
($FVF.domain_prev fvf@215)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@220)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert ($Set.equal
($FVF.domain_next fvf@208)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(pop) ; 5
(assert ($Set.equal
($FVF.domain_prev fvf@215)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length
($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert (implies
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1))))))
(assert ($Set.equal
($FVF.domain_next fvf@225)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@220)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0)))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert (forall ((i@201 Int)) (!
(implies
(=
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))
:pattern (($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))))))
(assert ($Set.equal
($FVF.domain_next fvf@208)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(push) ; 5
(set-option :timeout 0)
(declare-const grd@226 Bool)
(assert (implies grd@226 (not (not
(forall ((i@201 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)
(and
(implies
(<
(+ i@201 1)
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(+ i@201 1))))
(and
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- i@201 1))))
(and
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))))))))
(check-sat grd@226)
; unknown
; 0.38s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@227 Bool)
(assert (implies grd@227 (not (forall ((i@201 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)
(and
(implies
(<
(+ i@201 1)
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(+ i@201 1))))
(and
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- i@201 1))))
(and
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0))))))
:pattern (($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)))))))
(check-sat grd@227)
; unsat
; 0.12s
(get-info :all-statistics)
(push) ; 6
; [then-branch 26] QA i@201 :: i@201 in [0..|$t@66 ++ [newNode@57]|] ==> i@201 + 1 < |$t@66 ++ [newNode@57]| ==> Lookup(next,fvf@208,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 + 1] && 0 < i@201 ==> Lookup(prev,fvf@215,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 - 1] && Lookup(prev,fvf@220,$t@66 ++ [newNode@57][0]) == $t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1] && Lookup(next,fvf@225,$t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1]) == $t@66 ++ [newNode@57][0]
(assert (forall ((i@201 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)
(and
(implies
(<
(+ i@201 1)
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(+ i@201 1))))
(and
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- i@201 1))))
(and
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))) 1)))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0))))))
:pattern (($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201)))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
(declare-const i@228 Int)
(push) ; 7
; [eval] (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 8
(set-option :timeout 0)
(declare-const grd@229 Bool)
(assert (implies grd@229 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228)))))
(check-sat grd@229)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@230 Bool)
(assert (implies grd@230 (not ($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228))))
(check-sat grd@230)
; unknown
; 0.02s
(get-info :all-statistics)
(push) ; 9
; [then-branch 27] i@228 in [0..|$t@66 ++ [newNode@57]|]
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228))
; [eval] !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (this.nodes[i] in this.nodes[i + 1..])
; [eval] this.nodes[i + 1..]
; [eval] i + 1
; [eval] this.nodes[i]
(pop) ; 9
(push) ; 9
; [else-branch 27] !i@228 in [0..|$t@66 ++ [newNode@57]|]
(assert (not
($Seq.contains
($Seq.range 0 ($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228)))
(pop) ; 9
(pop) ; 8
(pop) ; 7
(pop) ; 6
; [dead else-branch 26] !QA i@201 :: i@201 in [0..|$t@66 ++ [newNode@57]|] ==> i@201 + 1 < |$t@66 ++ [newNode@57]| ==> Lookup(next,fvf@208,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 + 1] && 0 < i@201 ==> Lookup(prev,fvf@215,$t@66 ++ [newNode@57][i@201]) == $t@66 ++ [newNode@57][i@201 - 1] && Lookup(prev,fvf@220,$t@66 ++ [newNode@57][0]) == $t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1] && Lookup(next,fvf@225,$t@66 ++ [newNode@57][|$t@66 ++ [newNode@57]| - 1]) == $t@66 ++ [newNode@57][0]
(pop) ; 5
(set-option :timeout 0)
(declare-const grd@231 Bool)
(assert (implies grd@231 (not (and
(forall ((i@201 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)
(and
(implies
(<
(+ i@201 1)
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(+ i@201 1))))
(and
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- i@201 1))))
(and
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))))
(forall ((i@228 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228)
(not
($Seq.contains
($Seq.drop ($Seq.append $t@66 ($Seq.singleton newNode@57)) (+ i@228 1))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@228))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228))))))))
(check-sat grd@231)
; unsat
; 0.45s
(get-info :all-statistics)
(assert (and
(forall ((i@201 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201)
(and
(implies
(<
(+ i@201 1)
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
(=
($FVF.lookup_next fvf@208 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(+ i@201 1))))
(and
(implies
(< 0 i@201)
(=
($FVF.lookup_prev fvf@215 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
i@201))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(- i@201 1))))
(and
(=
($FVF.lookup_prev fvf@220 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
0))
($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
(=
($FVF.lookup_next fvf@225 ($Seq.index
($Seq.append $t@66 ($Seq.singleton newNode@57))
(-
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57)))
1)))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) 0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))
:pattern (($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@201))))
(forall ((i@228 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228)
(not
($Seq.contains
($Seq.drop ($Seq.append $t@66 ($Seq.singleton newNode@57)) (+ i@228 1))
($Seq.index ($Seq.append $t@66 ($Seq.singleton newNode@57)) i@228))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length ($Seq.append $t@66 ($Seq.singleton newNode@57))))
i@228))))))
(pop) ; 4
(push) ; 4
; [else-branch 19] index@5 != 0
(assert (not (= index@5 0)))
(pop) ; 4
; [eval] !(index == 0)
; [eval] index == 0
(set-option :timeout 0)
(declare-const grd@232 Bool)
(assert (implies grd@232 (not (= index@5 0))))
(check-sat grd@232)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@233 Bool)
(assert (implies grd@233 (not (not (= index@5 0)))))
(check-sat grd@233)
; unknown
; 0.01s
(get-info :all-statistics)
(push) ; 4
; [then-branch 28] index@5 != 0
(assert (not (= index@5 0)))
; [exec]
; this.nodes := this.nodes[..index] ++ Seq(newNode) ++ this.nodes[index..]
; [eval] this.nodes[..index] ++ Seq(newNode) ++ this.nodes[index..]
; [eval] this.nodes[..index] ++ Seq(newNode)
; [eval] this.nodes[..index]
; [eval] Seq(newNode)
(assert (= ($Seq.length ($Seq.singleton newNode@57)) 1))
; [eval] this.nodes[index..]
; [exec]
; fold acc(Valid(this), write)
; [eval] (this.header in this.nodes)
(set-option :timeout 0)
(declare-const grd@234 Bool)
(assert (implies grd@234 (not ($Seq.contains
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
$t@63))))
(check-sat grd@234)
; unsat
; 0.00s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
$t@63))
; [eval] !(null in this.nodes)
; [eval] (null in this.nodes)
(set-option :timeout 0)
(declare-const grd@235 Bool)
(assert (implies grd@235 (not (not
($Seq.contains
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
$Ref.null)))))
(check-sat grd@235)
; unsat
; 0.02s
(get-info :all-statistics)
(assert (not
($Seq.contains
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
$Ref.null)))
; [eval] 0 < |this.nodes|
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@236 Bool)
(assert (implies grd@236 (not (<
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))))))
(check-sat grd@236)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (<
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))))
; [eval] this.header == this.nodes[0]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@237 Bool)
(assert (implies grd@237 (not (=
$t@63
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(check-sat grd@237)
; unsat
; 0.00s
(get-info :all-statistics)
(assert (=
$t@63
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
(declare-const i@238 Int)
(declare-const fvf@239 $FVF<$Seq<$Ref>>)
(declare-const fvf@240 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@239 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@239) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@240 this@1)
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
($Set.equal ($FVF.domain_nodes fvf@240) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@241 Bool)
(assert (implies grd@241 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@241)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@242 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@242 this@1)
($FVF.lookup_nodes fvf@240 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@242 this@1)
($FVF.lookup_nodes fvf@239 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@242)
($Set.union ($FVF.domain_nodes fvf@239) ($FVF.domain_nodes fvf@240))))
(set-option :timeout 0)
(declare-const grd@243 Bool)
(assert (implies grd@243 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
i@238)))))
(check-sat grd@243)
; unknown
; 0.03s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
i@238))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@244 Bool)
(assert (implies grd@244 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@244)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@245 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@246 Bool)
(assert (implies grd@246 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@246)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-fun inv@247 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) (inv@247 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@242 this@1) (inv@247 $r))))))
(assert (forall ((i@238 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
i@238)
(= (inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)) i@238))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))))
(declare-const fvf@248 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@249 Bool)
(assert (implies grd@249 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@249)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@250 Bool)
(assert (implies grd@250 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@250)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@251 Bool)
(assert (implies grd@251 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@251)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@252 Bool)
(assert (implies grd@252 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@252)
; unknown
; 0.05s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@253 Bool)
(assert (implies grd@253 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range
0
($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_prev fvf@125 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238))
(ite (= $r ($FVF.lookup_prev fvf@125 newNode@57)) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@253)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@254 Bool)
(assert (implies grd@254 (not (=
(-
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@242 this@1)))
(inv@247 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@254)
; unsat
; 0.01s
(get-info :all-statistics)
(assert (forall ((i@238 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))
($FVF.lookup_next $t@73 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))
:pattern (($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))))
(assert (forall ((i@238 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))
($FVF.lookup_next fvf@77 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))
:pattern (($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))))
(assert (forall ((i@238 Int)) (!
(implies
(=
($Seq.index ($FVF.lookup_nodes fvf@242 this@1) i@238)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))
($FVF.lookup_next fvf@132 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))
:pattern (($FVF.lookup_next fvf@248 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($FVF.lookup_nodes fvf@242 this@1)
i@238))))))
(assert ($Set.equal
($FVF.domain_next fvf@248)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(declare-const i@255 Int)
(declare-const fvf@256 $FVF<$Seq<$Ref>>)
(declare-const fvf@257 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@256 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@256) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@257 this@1)
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
($Set.equal ($FVF.domain_nodes fvf@257) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@258 Bool)
(assert (implies grd@258 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@258)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@259 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@259 this@1)
($FVF.lookup_nodes fvf@257 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@259 this@1)
($FVF.lookup_nodes fvf@256 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@259)
($Set.union ($FVF.domain_nodes fvf@256) ($FVF.domain_nodes fvf@257))))
(set-option :timeout 0)
(declare-const grd@260 Bool)
(assert (implies grd@260 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
i@255)))))
(check-sat grd@260)
; unknown
; 0.05s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
i@255))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@261 Bool)
(assert (implies grd@261 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@261)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@262 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@263 Bool)
(assert (implies grd@263 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@263)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-fun inv@264 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) (inv@264 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@259 this@1) (inv@264 $r))))))
(assert (forall ((i@255 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
i@255)
(= (inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)) i@255))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))))
(declare-const fvf@265 $FVF<$Ref>)
(set-option :timeout 500)
(declare-const grd@266 Bool)
(assert (implies grd@266 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@266)
; unknown
; 0.04s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@267 Bool)
(assert (implies grd@267 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@267)
; unknown
; 0.04s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@268 Bool)
(assert (implies grd@268 (not (forall (($r $Ref)) (!
(=
(-
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@268)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@269 Bool)
(assert (implies grd@269 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
$Perm.No))))
(check-sat grd@269)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@270 Bool)
(assert (implies grd@270 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range
0
($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(= $r ($FVF.lookup_next fvf@134 newNode@57))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255))
(ite (= $r ($FVF.lookup_next fvf@134 newNode@57)) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@270)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@271 Bool)
(assert (implies grd@271 (not (=
(-
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@259 this@1)))
(inv@264 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
$Perm.Write
$Perm.No)
$Perm.No)))))
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@271)
; unsat
; 0.06s
(get-info :all-statistics)
(assert (forall ((i@255 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))
($FVF.lookup_prev $t@78 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))
:pattern (($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))))
(assert (forall ((i@255 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255) newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))
($FVF.lookup_prev fvf@123 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))
:pattern (($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))))
(assert (forall ((i@255 Int)) (!
(implies
(=
($Seq.index ($FVF.lookup_nodes fvf@259 this@1) i@255)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))
($FVF.lookup_prev fvf@141 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))
:pattern (($FVF.lookup_prev fvf@265 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($FVF.lookup_nodes fvf@259 this@1)
i@255))))))
(assert ($Set.equal
($FVF.domain_prev fvf@265)
($Set.union
($Set.union ($FVF.domain_prev fvf@141) ($FVF.domain_prev fvf@123))
($FVF.domain_prev $t@78))))
(declare-const i@272 Int)
(declare-const fvf@273 $FVF<$Seq<$Ref>>)
(declare-const fvf@274 $FVF<$Seq<$Ref>>)
(assert (and
($Seq.equal ($FVF.lookup_nodes fvf@273 newNode@57) nodes@59)
($Set.equal ($FVF.domain_nodes fvf@273) ($Set.singleton newNode@57))))
(assert (and
($Seq.equal
($FVF.lookup_nodes fvf@274 this@1)
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
($Set.equal ($FVF.domain_nodes fvf@274) ($Set.singleton this@1))))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@275 Bool)
(assert (implies grd@275 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@275)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@276 $FVF<$Seq<$Ref>>)
(assert ($Seq.equal
($FVF.lookup_nodes fvf@276 this@1)
($FVF.lookup_nodes fvf@274 this@1)))
(assert (implies
(= this@1 newNode@57)
($Seq.equal
($FVF.lookup_nodes fvf@276 this@1)
($FVF.lookup_nodes fvf@273 this@1))))
(assert ($Set.equal
($FVF.domain_nodes fvf@276)
($Set.union ($FVF.domain_nodes fvf@273) ($FVF.domain_nodes fvf@274))))
(set-option :timeout 0)
(declare-const grd@277 Bool)
(assert (implies grd@277 (not (not
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
i@272)))))
(check-sat grd@277)
; unknown
; 0.10s
(get-info :all-statistics)
(assert ($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
i@272))
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@278 Bool)
(assert (implies grd@278 (not (< $Perm.No (+ (ite (= this@1 newNode@57) $Perm.Write $Perm.No) $Perm.Write)))))
(check-sat grd@278)
; unsat
; 0.01s
(get-info :all-statistics)
(declare-const fvf@279 $FVF<$Seq<$Ref>>)
(set-option :timeout 0)
(declare-const grd@280 Bool)
(assert (implies grd@280 (not (< $Perm.Write (+ $Perm.Write $Perm.Write)))))
(check-sat grd@280)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-fun inv@281 ($Ref) Int)
(assert (forall (($r $Ref)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 $r))
(= ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) (inv@281 $r)) $r))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@276 this@1) (inv@281 $r))))))
(assert (forall ((i@272 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
i@272)
(= (inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)) i@272))
:pattern (($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))))
(declare-const fvf@282 $FVF<Int>)
(set-option :timeout 500)
(declare-const grd@283 Bool)
(assert (implies grd@283 (not (forall (($r $Ref)) (!
(=
(-
(ite (= $r newNode@57) $Perm.Write $Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@283)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@284 Bool)
(assert (implies grd@284 (not (=
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272) newNode@57)
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@284)
; unknown
; 0.01s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@285 Bool)
(assert (implies grd@285 (not (forall (($r $Ref)) (!
(=
(-
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@85 $r))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 $r))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 $r))
$Perm.Write
$Perm.No)
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272))
(ite (= $r newNode@57) $Perm.Write $Perm.No)
$Perm.No)))
(ite
(= $r ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272))
(ite
($Seq.contains ($Seq.range 0 ($Seq.length $t@66)) (inv@85 $r))
$Perm.Write
$Perm.No)
$Perm.No)))
$Perm.No)
)))))
(check-sat grd@285)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 500)
(declare-const grd@286 Bool)
(assert (implies grd@286 (not (=
(-
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272) newNode@57)
$Perm.Write
$Perm.No)))
($Perm.min
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
($Perm.min
(ite
($Seq.contains
($Seq.range 0 ($Seq.length ($FVF.lookup_nodes fvf@276 this@1)))
(inv@281 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)
(ite
(= ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272) newNode@57)
$Perm.Write
$Perm.No)))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@85 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
$Perm.Write
$Perm.No)))
$Perm.No))))
(check-sat grd@286)
; unsat
; 0.07s
(get-info :all-statistics)
(assert (forall ((i@272 Int)) (!
(implies
(= ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272) newNode@57)
(=
($FVF.lookup_value fvf@282 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))
($FVF.lookup_value fvf@86 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))))
:pattern (($FVF.lookup_value fvf@282 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272)))
:pattern (($FVF.lookup_value fvf@86 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))))))
(assert (forall ((i@272 Int)) (!
(implies
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@85 ($Seq.index ($FVF.lookup_nodes fvf@276 this@1) i@272)))
(=
($FVF.lookup_value fvf@282 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))
($FVF.lookup_value $t@83 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))))
:pattern (($FVF.lookup_value fvf@282 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272)))
:pattern (($FVF.lookup_value $t@83 ($Seq.index
($FVF.lookup_nodes fvf@276 this@1)
i@272))))))
(assert ($Set.equal
($FVF.domain_value fvf@282)
($Set.union ($FVF.domain_value $t@83) ($FVF.domain_value fvf@86))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))) && (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))))
(declare-const i@287 Int)
(push) ; 5
; [eval] (i in [0..|this.nodes|)) ==> ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 6
(set-option :timeout 0)
(declare-const grd@288 Bool)
(assert (implies grd@288 (not (not
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)))))
(check-sat grd@288)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@289 Bool)
(assert (implies grd@289 (not ($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))))
(check-sat grd@289)
; unknown
; 0.02s
(get-info :all-statistics)
(push) ; 7
; [then-branch 29] i@287 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|]
(assert ($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
; [eval] ((i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])) && (((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])))
; [eval] (i + 1 < |this.nodes|) ==> (this.nodes[i].next == this.nodes[i + 1])
; [eval] i + 1 < |this.nodes|
; [eval] i + 1
; [eval] |this.nodes|
(push) ; 8
(set-option :timeout 0)
(declare-const grd@290 Bool)
(assert (implies grd@290 (not (not
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))))))
(check-sat grd@290)
; unknown
; 0.02s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@291 Bool)
(assert (implies grd@291 (not (<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))))))
(check-sat grd@291)
; unknown
; 0.02s
(get-info :all-statistics)
(push) ; 9
; [then-branch 30] i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|
(assert (<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))))
; [eval] this.nodes[i].next == this.nodes[i + 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@292 Bool)
(assert (implies grd@292 (not (not
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
$Ref.null)))))
(check-sat grd@292)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@293 Bool)
(assert (implies grd@293 (not (<
$Perm.No
(+
(+
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))))))
(check-sat grd@293)
; unsat
; 0.12s
(get-info :all-statistics)
(declare-const fvf@294 $FVF<$Ref>)
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert ($Set.equal
($FVF.domain_next fvf@294)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
; [eval] this.nodes[i + 1]
; [eval] i + 1
(pop) ; 9
(push) ; 9
; [else-branch 30] !i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|
(assert (not
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))))
(pop) ; 9
(pop) ; 8
(assert ($Set.equal
($FVF.domain_next fvf@294)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(push) ; 8
(set-option :timeout 0)
(declare-const grd@295 Bool)
(assert (implies grd@295 (not (not
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))))))
(check-sat grd@295)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@296 Bool)
(assert (implies grd@296 (not (implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1)))))))
(check-sat grd@296)
; unsat
; 0.22s
(get-info :all-statistics)
(push) ; 9
; [then-branch 31] i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| ==> Lookup(next,fvf@294,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 + 1]
(assert (implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1)))))
; [eval] ((0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])) && ((this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0]))
; [eval] (0 < i) ==> (this.nodes[i].prev == this.nodes[i - 1])
; [eval] 0 < i
(push) ; 10
(set-option :timeout 0)
(declare-const grd@297 Bool)
(assert (implies grd@297 (not (not (< 0 i@287)))))
(check-sat grd@297)
; unknown
; 0.03s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@298 Bool)
(assert (implies grd@298 (not (< 0 i@287))))
(check-sat grd@298)
; unknown
; 0.06s
(get-info :all-statistics)
(push) ; 11
; [then-branch 32] 0 < i@287
(assert (< 0 i@287))
; [eval] this.nodes[i].prev == this.nodes[i - 1]
; [eval] this.nodes[i]
(set-option :timeout 0)
(declare-const grd@299 Bool)
(assert (implies grd@299 (not (not
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
$Ref.null)))))
(check-sat grd@299)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@300 Bool)
(assert (implies grd@300 (not (<
$Perm.No
(+
(+
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No)))
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No))))))
(check-sat grd@300)
; unsat
; 0.03s
(get-info :all-statistics)
(declare-const fvf@301 $FVF<$Ref>)
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert ($Set.equal
($FVF.domain_prev fvf@301)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
; [eval] this.nodes[i - 1]
; [eval] i - 1
(pop) ; 11
(push) ; 11
; [else-branch 32] !0 < i@287
(assert (not (< 0 i@287)))
(pop) ; 11
(pop) ; 10
(assert ($Set.equal
($FVF.domain_prev fvf@301)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(push) ; 10
(set-option :timeout 0)
(declare-const grd@302 Bool)
(assert (implies grd@302 (not (not
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))))))
(check-sat grd@302)
; unknown
; 0.24s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@303 Bool)
(assert (implies grd@303 (not (implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1)))))))
(check-sat grd@303)
; unsat
; 6.37s
(get-info :all-statistics)
(push) ; 11
; [then-branch 33] 0 < i@287 ==> Lookup(prev,fvf@301,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 - 1]
(assert (implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1)))))
; [eval] (this.nodes[0].prev == this.nodes[|this.nodes| - 1]) && (this.nodes[|this.nodes| - 1].next == this.nodes[0])
; [eval] this.nodes[0].prev == this.nodes[|this.nodes| - 1]
; [eval] this.nodes[0]
(set-option :timeout 0)
(declare-const grd@304 Bool)
(assert (implies grd@304 (not (not
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
$Ref.null)))))
(check-sat grd@304)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@305 Bool)
(assert (implies grd@305 (not (<
$Perm.No
(+
(+
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No)))
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No))))))
(check-sat grd@305)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@306 $FVF<$Ref>)
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@306)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(push) ; 12
(set-option :timeout 0)
(declare-const grd@307 Bool)
(assert (implies grd@307 (not (not
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))))))
(check-sat grd@307)
; unknown
; 0.16s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@308 Bool)
(assert (implies grd@308 (not (=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(check-sat grd@308)
; unsat
; 0.33s
(get-info :all-statistics)
(push) ; 13
; [then-branch 34] Lookup(prev,fvf@306,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1]
(assert (=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
; [eval] this.nodes[|this.nodes| - 1].next == this.nodes[0]
; [eval] this.nodes[|this.nodes| - 1]
; [eval] |this.nodes| - 1
; [eval] |this.nodes|
(set-option :timeout 0)
(declare-const grd@309 Bool)
(assert (implies grd@309 (not (not
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
$Ref.null)))))
(check-sat grd@309)
; unsat
; 0.00s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@310 Bool)
(assert (implies grd@310 (not (<
$Perm.No
(+
(+
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))))))
(check-sat grd@310)
; unsat
; 0.00s
(get-info :all-statistics)
(declare-const fvf@311 $FVF<$Ref>)
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
; [eval] this.nodes[0]
(pop) ; 13
; [dead else-branch 34] Lookup(prev,fvf@306,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]) != $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1]
(pop) ; 12
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(pop) ; 11
; [dead else-branch 33] !0 < i@287 ==> Lookup(prev,fvf@301,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 - 1]
(pop) ; 10
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@306)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(pop) ; 9
; [dead else-branch 31] !i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| ==> Lookup(next,fvf@294,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 + 1]
(pop) ; 8
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert ($Set.equal
($FVF.domain_prev fvf@306)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert ($Set.equal
($FVF.domain_prev fvf@301)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(pop) ; 7
(push) ; 7
; [else-branch 29] !i@287 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|]
(assert (not
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)))
(pop) ; 7
(pop) ; 6
(assert ($Set.equal
($FVF.domain_prev fvf@301)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@306)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert ($Set.equal
($FVF.domain_next fvf@294)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(pop) ; 5
(assert ($Set.equal
($FVF.domain_prev fvf@301)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1))))))
(assert ($Set.equal
($FVF.domain_next fvf@311)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(assert ($Set.equal
($FVF.domain_prev fvf@306)
($Set.union
($Set.union ($FVF.domain_prev $t@78) ($FVF.domain_prev fvf@123))
($FVF.domain_prev fvf@141))))
(assert (implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@81 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev $t@78 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@123 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)
($FVF.lookup_next fvf@134 newNode@57))
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($FVF.lookup_prev fvf@141 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0)))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
($Perm.min
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No)))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
($Seq.contains
($Seq.range 0 ($Seq.length $t@66))
(inv@76 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next $t@73 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(<
$Perm.No
(-
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
($Perm.min
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
$Perm.Write
$Perm.No)
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(ite
(=
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
newNode@57)
$Perm.Write
$Perm.No)
$Perm.No))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@77 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert (forall ((i@287 Int)) (!
(implies
(=
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)
($FVF.lookup_prev fvf@125 newNode@57))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
:pattern (($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))
:pattern (($FVF.lookup_next fvf@132 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))
(assert ($Set.equal
($FVF.domain_next fvf@294)
($Set.union
($Set.union ($FVF.domain_next fvf@132) ($FVF.domain_next fvf@77))
($FVF.domain_next $t@73))))
(push) ; 5
(set-option :timeout 0)
(declare-const grd@312 Bool)
(assert (implies grd@312 (not (not
(forall ((i@287 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)
(and
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))
(and
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))
(and
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))))))
(check-sat grd@312)
; unknown
; 0.30s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@313 Bool)
(assert (implies grd@313 (not (forall ((i@287 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)
(and
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))
(and
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))
(and
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))))))
(check-sat grd@313)
; unsat
; 0.97s
(get-info :all-statistics)
(push) ; 6
; [then-branch 35] QA i@287 :: i@287 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|] ==> i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| ==> Lookup(next,fvf@294,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 + 1] && 0 < i@287 ==> Lookup(prev,fvf@301,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 - 1] && Lookup(prev,fvf@306,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1] && Lookup(next,fvf@311,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]
(assert (forall ((i@287 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)
(and
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))
(and
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))
(and
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287)))))
; [eval] (forall i: Int :: (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..]))
(declare-const i@314 Int)
(push) ; 7
; [eval] (i in [0..|this.nodes|)) ==> !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (i in [0..|this.nodes|))
; [eval] [0..|this.nodes|)
; [eval] |this.nodes|
(push) ; 8
(set-option :timeout 0)
(declare-const grd@315 Bool)
(assert (implies grd@315 (not (not
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314)))))
(check-sat grd@315)
; unknown
; 0.08s
(get-info :all-statistics)
(set-option :timeout 0)
(declare-const grd@316 Bool)
(assert (implies grd@316 (not ($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314))))
(check-sat grd@316)
; unknown
; 0.05s
(get-info :all-statistics)
(push) ; 9
; [then-branch 36] i@314 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|]
(assert ($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314))
; [eval] !(this.nodes[i] in this.nodes[i + 1..])
; [eval] (this.nodes[i] in this.nodes[i + 1..])
; [eval] this.nodes[i + 1..]
; [eval] i + 1
; [eval] this.nodes[i]
(pop) ; 9
(push) ; 9
; [else-branch 36] !i@314 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|]
(assert (not
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314)))
(pop) ; 9
(pop) ; 8
(pop) ; 7
(pop) ; 6
; [dead else-branch 35] !QA i@287 :: i@287 in [0..|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]|] ==> i@287 + 1 < |$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| ==> Lookup(next,fvf@294,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 + 1] && 0 < i@287 ==> Lookup(prev,fvf@301,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][i@287 - 1] && Lookup(prev,fvf@306,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1] && Lookup(next,fvf@311,$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][|$t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:]| - 1]) == $t@66[:index@5] ++ [newNode@57] ++ $t@66[index@5:][0]
(pop) ; 5
(set-option :timeout 0)
(declare-const grd@317 Bool)
(assert (implies grd@317 (not (and
(forall ((i@287 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)
(and
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))
(and
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))
(and
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
(forall ((i@314 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314)
(not
($Seq.contains
($Seq.drop
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@314 1))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@314))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314))))))))
(check-sat grd@317)
; unsat
; 1.74s
(get-info :all-statistics)
(assert (and
(forall ((i@287 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287)
(and
(implies
(<
(+ i@287 1)
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
(=
($FVF.lookup_next fvf@294 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@287 1))))
(and
(implies
(< 0 i@287)
(=
($FVF.lookup_prev fvf@301 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(- i@287 1))))
(and
(=
($FVF.lookup_prev fvf@306 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
(=
($FVF.lookup_next fvf@311 ($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(-
($Seq.length
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5)))
1)))
($Seq.index
($Seq.append
($Seq.append
($Seq.take $t@66 index@5)
($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
0))))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))
:pattern (($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@287))))
(forall ((i@314 Int)) (!
(implies
($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314)
(not
($Seq.contains
($Seq.drop
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
(+ i@314 1))
($Seq.index
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))
i@314))))
:pattern (($Seq.contains
($Seq.range
0
($Seq.length
($Seq.append
($Seq.append ($Seq.take $t@66 index@5) ($Seq.singleton newNode@57))
($Seq.drop $t@66 index@5))))
i@314))))))
(pop) ; 4
(push) ; 4
; [else-branch 28] index@5 == 0
(assert (= index@5 0))
(pop) ; 4
(pop) ; 3
(pop) ; 2
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment