Created
June 11, 2015 13:03
-
-
Save anonymous/16e489ce5c513e8c4bc6 to your computer and use it in GitHub Desktop.
SMT input file
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(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