From fdc06b55b75c43b50846f9f43baafa7c46142145 Mon Sep 17 00:00:00 2001 From: zafer-esen Date: Fri, 9 Feb 2024 18:32:15 +0100 Subject: [PATCH] Monomorphic Field and collection types (#4597) Removes the type argument from `Field`, and from all collection types. All heap and collection elements are now always of type `Box`. This has the effect of very slightly increasing brittleness on some particularly brittle examples, though it has minimal effect on most code. The benefits of the simplification (and the opportunities it opens for future optimization) seem worth the tradeoff, however. By submitting this pull request, I confirm that my contribution is made under the terms of the MIT license. --------- Co-authored-by: Aaron Tomb --- Source/DafnyCore/DafnyPrelude.bpl | 678 +++--- Source/DafnyCore/GeneratedFromDafny.cs | 2 +- .../Verifier/BoogieGenerator.BoogieFactory.cs | 103 +- .../Verifier/BoogieGenerator.DataTypes.cs | 6 +- .../Verifier/BoogieGenerator.Decreases.cs | 8 +- .../BoogieGenerator.ExpressionTranslator.cs | 42 +- .../BoogieGenerator.ExpressionWellformed.cs | 8 +- .../Verifier/BoogieGenerator.Fields.cs | 2 +- .../Verifier/BoogieGenerator.Functions.cs | 17 +- .../Verifier/BoogieGenerator.Iterators.cs | 4 +- .../Verifier/BoogieGenerator.Methods.cs | 28 +- .../Verifier/BoogieGenerator.TrStatement.cs | 37 +- .../Verifier/BoogieGenerator.Types.cs | 13 +- Source/DafnyCore/Verifier/BoogieGenerator.cs | 228 +- .../Performance/ThreadUsageTest.cs | 4 +- .../CounterExampleGeneration/DafnyModel.cs | 54 +- .../DafnyPipeline.Test/expectedProverLog.smt2 | 2118 ++++++++--------- .../binaries/DafnyStandardLibraries-cs.doo | Bin 1340 -> 1340 bytes .../binaries/DafnyStandardLibraries-go.doo | Bin 1360 -> 1360 bytes .../binaries/DafnyStandardLibraries-java.doo | Bin 1321 -> 1321 bytes .../binaries/DafnyStandardLibraries-js.doo | Bin 1867 -> 1867 bytes .../DafnyStandardLibraries-notarget.doo | Bin 1314 -> 1314 bytes .../binaries/DafnyStandardLibraries-py.doo | Bin 1331 -> 1331 bytes .../binaries/DafnyStandardLibraries.doo | Bin 56908 -> 56974 bytes .../Std/Arithmetic/Internal/ModInternals.dfy | 64 +- .../src/Std/Arithmetic/LittleEndianNat.dfy | 4 +- .../src/Std/JSON/ZeroCopy/Deserializer.dfy | 2 +- .../src/Std/Unicode/Utf8EncodingScheme.dfy | 2 +- Source/DafnyTestGeneration/ProgramModifier.cs | 4 +- .../concurrency/12-MutexLifetime-short.dfy | 2 +- .../LitTest/dafny0/ConcurrentAttribute.dfy | 7 +- .../dafny0/ConcurrentAttribute.dfy.expect | 8 +- .../LitTest/dafny0/Fuel.legacy.dfy.expect | 18 +- .../LitTest/dafny0/ReadsOnMethods.dfy.expect | 3 +- .../Snapshots0.run.legacy.dfy.expect | 2 +- .../LitTest/dafny2/pq-intrinsic-extrinsic.dfy | 2 +- .../LitTests/LitTest/dafny4/FlyingRobots.dfy | 2 +- .../LitTest/dafny4/Lucas-up.legacy.dfy | 4 +- .../LitTests/LitTest/dafny4/UnionFind.dfy | 2 +- .../git-issues/git-issue-2026.dfy.expect | 24 +- .../LitTest/git-issues/github-issue-2174.dfy | 4 + .../git-issues/github-issue-2174.dfy.expect | 2 +- ...-issue-listed-in-the-ironclad-notebook.dfy | 2 +- .../set-construction-is-a-good-trigger.dfy | 2 +- 44 files changed, 1710 insertions(+), 1802 deletions(-) diff --git a/Source/DafnyCore/DafnyPrelude.bpl b/Source/DafnyCore/DafnyPrelude.bpl index f1009b7163..d82cd33cc1 100644 --- a/Source/DafnyCore/DafnyPrelude.bpl +++ b/Source/DafnyCore/DafnyPrelude.bpl @@ -164,12 +164,14 @@ const $ArbitraryBoxValue: Box; function $Box(T): Box; function $Unbox(Box): T; -axiom (forall x : T :: { $Box(x) } $Unbox($Box(x)) == x); +axiom (forall x : T :: { $Box(x) } $Unbox($Box(x)) == x); +axiom (forall x : Box :: { $Unbox(x): T} $Box($Unbox(x): T) == x); + // Corresponding entries for boxes... // This could probably be solved by having Box also inhabit Ty -function $IsBox(T,Ty): bool; -function $IsAllocBox(T,Ty,Heap): bool; +function $IsBox(Box,Ty): bool; +function $IsAllocBox(Box,Ty,Heap): bool; axiom (forall bx : Box :: { $IsBox(bx, TInt) } @@ -188,26 +190,26 @@ axiom (forall bx : Box :: // generated programmatically. Except, Bv0 is given here. axiom (forall bx : Box :: { $IsBox(bx, TBitvector(0)) } - ( $IsBox(bx, TBitvector(0)) ==> $Box($Unbox(bx) : Bv0) == bx && $Is($Unbox(bx) : Set Box, TBitvector(0)))); + ( $IsBox(bx, TBitvector(0)) ==> $Box($Unbox(bx) : Bv0) == bx && $Is($Unbox(bx) : Bv0, TBitvector(0)))); axiom (forall bx : Box, t : Ty :: { $IsBox(bx, TSet(t)) } - ( $IsBox(bx, TSet(t)) ==> $Box($Unbox(bx) : Set Box) == bx && $Is($Unbox(bx) : Set Box, TSet(t)))); + ( $IsBox(bx, TSet(t)) ==> $Box($Unbox(bx) : Set) == bx && $Is($Unbox(bx) : Set, TSet(t)))); axiom (forall bx : Box, t : Ty :: { $IsBox(bx, TISet(t)) } - ( $IsBox(bx, TISet(t)) ==> $Box($Unbox(bx) : ISet Box) == bx && $Is($Unbox(bx) : ISet Box, TISet(t)))); + ( $IsBox(bx, TISet(t)) ==> $Box($Unbox(bx) : ISet) == bx && $Is($Unbox(bx) : ISet, TISet(t)))); axiom (forall bx : Box, t : Ty :: { $IsBox(bx, TMultiSet(t)) } - ( $IsBox(bx, TMultiSet(t)) ==> $Box($Unbox(bx) : MultiSet Box) == bx && $Is($Unbox(bx) : MultiSet Box, TMultiSet(t)))); + ( $IsBox(bx, TMultiSet(t)) ==> $Box($Unbox(bx) : MultiSet) == bx && $Is($Unbox(bx) : MultiSet, TMultiSet(t)))); axiom (forall bx : Box, t : Ty :: { $IsBox(bx, TSeq(t)) } - ( $IsBox(bx, TSeq(t)) ==> $Box($Unbox(bx) : Seq Box) == bx && $Is($Unbox(bx) : Seq Box, TSeq(t)))); + ( $IsBox(bx, TSeq(t)) ==> $Box($Unbox(bx) : Seq) == bx && $Is($Unbox(bx) : Seq, TSeq(t)))); axiom (forall bx : Box, s : Ty, t : Ty :: { $IsBox(bx, TMap(s, t)) } - ( $IsBox(bx, TMap(s, t)) ==> $Box($Unbox(bx) : Map Box Box) == bx && $Is($Unbox(bx) : Map Box Box, TMap(s, t)))); + ( $IsBox(bx, TMap(s, t)) ==> $Box($Unbox(bx) : Map) == bx && $Is($Unbox(bx) : Map, TMap(s, t)))); axiom (forall bx : Box, s : Ty, t : Ty :: { $IsBox(bx, TIMap(s, t)) } - ( $IsBox(bx, TIMap(s, t)) ==> $Box($Unbox(bx) : IMap Box Box) == bx && $Is($Unbox(bx) : IMap Box Box, TIMap(s, t)))); + ( $IsBox(bx, TIMap(s, t)) ==> $Box($Unbox(bx) : IMap) == bx && $Is($Unbox(bx) : IMap, TIMap(s, t)))); axiom (forall v : T, t : Ty :: { $IsBox($Box(v), t) } @@ -233,27 +235,27 @@ axiom(forall v : ORDINAL :: { $Is(v,TORDINAL) } $Is(v,TORDINAL)); // for bitvectors are generated programatically. Except, TBitvector(0) is given here. axiom (forall v: Bv0 :: { $Is(v, TBitvector(0)) } $Is(v, TBitvector(0))); -axiom (forall v: Set Box, t0: Ty :: { $Is(v, TSet(t0)) } +axiom (forall v: Set, t0: Ty :: { $Is(v, TSet(t0)) } $Is(v, TSet(t0)) <==> (forall bx: Box :: { v[bx] } v[bx] ==> $IsBox(bx, t0))); -axiom (forall v: ISet Box, t0: Ty :: { $Is(v, TISet(t0)) } +axiom (forall v: ISet, t0: Ty :: { $Is(v, TISet(t0)) } $Is(v, TISet(t0)) <==> (forall bx: Box :: { v[bx] } v[bx] ==> $IsBox(bx, t0))); -axiom (forall v: MultiSet Box, t0: Ty :: { $Is(v, TMultiSet(t0)) } +axiom (forall v: MultiSet, t0: Ty :: { $Is(v, TMultiSet(t0)) } $Is(v, TMultiSet(t0)) <==> (forall bx: Box :: { v[bx] } 0 < v[bx] ==> $IsBox(bx, t0))); -axiom (forall v: MultiSet Box, t0: Ty :: { $Is(v, TMultiSet(t0)) } +axiom (forall v: MultiSet, t0: Ty :: { $Is(v, TMultiSet(t0)) } $Is(v, TMultiSet(t0)) ==> $IsGoodMultiSet(v)); -axiom (forall v: Seq Box, t0: Ty :: { $Is(v, TSeq(t0)) } +axiom (forall v: Seq, t0: Ty :: { $Is(v, TSeq(t0)) } $Is(v, TSeq(t0)) <==> (forall i : int :: { Seq#Index(v, i) } 0 <= i && i < Seq#Length(v) ==> $IsBox(Seq#Index(v, i), t0))); -axiom (forall v: Map Box Box, t0: Ty, t1: Ty :: +axiom (forall v: Map, t0: Ty, t1: Ty :: { $Is(v, TMap(t0, t1)) } $Is(v, TMap(t0, t1)) <==> (forall bx: Box :: @@ -262,13 +264,13 @@ axiom (forall v: Map Box Box, t0: Ty, t1: Ty :: $IsBox(Map#Elements(v)[bx], t1) && $IsBox(bx, t0))); -axiom (forall v: Map Box Box, t0: Ty, t1: Ty :: +axiom (forall v: Map, t0: Ty, t1: Ty :: { $Is(v, TMap(t0, t1)) } $Is(v, TMap(t0, t1)) ==> $Is(Map#Domain(v), TSet(t0)) && $Is(Map#Values(v), TSet(t1)) && $Is(Map#Items(v), TSet(Tclass._System.Tuple2(t0, t1)))); -axiom (forall v: IMap Box Box, t0: Ty, t1: Ty :: +axiom (forall v: IMap, t0: Ty, t1: Ty :: { $Is(v, TIMap(t0, t1)) } $Is(v, TIMap(t0, t1)) <==> (forall bx: Box :: @@ -276,7 +278,7 @@ axiom (forall v: IMap Box Box, t0: Ty, t1: Ty :: IMap#Domain(v)[bx] ==> $IsBox(IMap#Elements(v)[bx], t1) && $IsBox(bx, t0))); -axiom (forall v: IMap Box Box, t0: Ty, t1: Ty :: +axiom (forall v: IMap, t0: Ty, t1: Ty :: { $Is(v, TIMap(t0, t1)) } $Is(v, TIMap(t0, t1)) ==> $Is(IMap#Domain(v), TISet(t0)) && @@ -292,25 +294,25 @@ axiom(forall h : Heap, v : ORDINAL :: { $IsAlloc(v,TORDINAL,h) } $IsAlloc(v,TORD axiom (forall v: Bv0, h: Heap :: { $IsAlloc(v, TBitvector(0), h) } $IsAlloc(v, TBitvector(0), h)); -axiom (forall v: Set Box, t0: Ty, h: Heap :: { $IsAlloc(v, TSet(t0), h) } +axiom (forall v: Set, t0: Ty, h: Heap :: { $IsAlloc(v, TSet(t0), h) } $IsAlloc(v, TSet(t0), h) <==> (forall bx: Box :: { v[bx] } v[bx] ==> $IsAllocBox(bx, t0, h))); -axiom (forall v: ISet Box, t0: Ty, h: Heap :: { $IsAlloc(v, TISet(t0), h) } +axiom (forall v: ISet, t0: Ty, h: Heap :: { $IsAlloc(v, TISet(t0), h) } $IsAlloc(v, TISet(t0), h) <==> (forall bx: Box :: { v[bx] } v[bx] ==> $IsAllocBox(bx, t0, h))); -axiom (forall v: MultiSet Box, t0: Ty, h: Heap :: { $IsAlloc(v, TMultiSet(t0), h) } +axiom (forall v: MultiSet, t0: Ty, h: Heap :: { $IsAlloc(v, TMultiSet(t0), h) } $IsAlloc(v, TMultiSet(t0), h) <==> (forall bx: Box :: { v[bx] } 0 < v[bx] ==> $IsAllocBox(bx, t0, h))); -axiom (forall v: Seq Box, t0: Ty, h: Heap :: { $IsAlloc(v, TSeq(t0), h) } +axiom (forall v: Seq, t0: Ty, h: Heap :: { $IsAlloc(v, TSeq(t0), h) } $IsAlloc(v, TSeq(t0), h) <==> (forall i : int :: { Seq#Index(v, i) } 0 <= i && i < Seq#Length(v) ==> $IsAllocBox(Seq#Index(v, i), t0, h))); -axiom (forall v: Map Box Box, t0: Ty, t1: Ty, h: Heap :: +axiom (forall v: Map, t0: Ty, t1: Ty, h: Heap :: { $IsAlloc(v, TMap(t0, t1), h) } $IsAlloc(v, TMap(t0, t1), h) <==> (forall bx: Box :: @@ -319,7 +321,7 @@ axiom (forall v: Map Box Box, t0: Ty, t1: Ty, h: Heap :: $IsAllocBox(Map#Elements(v)[bx], t1, h) && $IsAllocBox(bx, t0, h))); -axiom (forall v: IMap Box Box, t0: Ty, t1: Ty, h: Heap :: +axiom (forall v: IMap, t0: Ty, t1: Ty, h: Heap :: { $IsAlloc(v, TIMap(t0, t1), h) } $IsAlloc(v, TIMap(t0, t1), h) <==> (forall bx: Box :: @@ -364,7 +366,7 @@ axiom (forall a: ClassName, b: ClassName :: { TypeTuple(a,b) } type HandleType; -function SetRef_to_SetBox(s: [ref]bool): Set Box; +function SetRef_to_SetBox(s: [ref]bool): Set; axiom (forall s: [ref]bool, bx: Box :: { SetRef_to_SetBox(s)[bx] } SetRef_to_SetBox(s)[bx] == s[$Unbox(bx): ref]); axiom (forall s: [ref]bool :: { SetRef_to_SetBox(s) } @@ -503,43 +505,43 @@ axiom (forall f : [LayerType]A, ly : LayerType :: { AtLayer(f,$LS(ly)) } AtLa // -- Fields ----------------------------------------------------- // --------------------------------------------------------------- -type Field alpha; +type Field; -function FDim(Field T): int uses { +function FDim(Field): int uses { axiom FDim(alloc) == 0; } -function IndexField(int): Field Box; +function IndexField(int): Field; axiom (forall i: int :: { IndexField(i) } FDim(IndexField(i)) == 1); -function IndexField_Inverse(Field T): int; +function IndexField_Inverse(Field): int; axiom (forall i: int :: { IndexField(i) } IndexField_Inverse(IndexField(i)) == i); -function MultiIndexField(Field Box, int): Field Box; -axiom (forall f: Field Box, i: int :: { MultiIndexField(f,i) } FDim(MultiIndexField(f,i)) == FDim(f) + 1); -function MultiIndexField_Inverse0(Field T): Field T; -function MultiIndexField_Inverse1(Field T): int; -axiom (forall f: Field Box, i: int :: { MultiIndexField(f,i) } +function MultiIndexField(Field, int): Field; +axiom (forall f: Field, i: int :: { MultiIndexField(f,i) } FDim(MultiIndexField(f,i)) == FDim(f) + 1); +function MultiIndexField_Inverse0(Field): Field; +function MultiIndexField_Inverse1(Field): int; +axiom (forall f: Field, i: int :: { MultiIndexField(f,i) } MultiIndexField_Inverse0(MultiIndexField(f,i)) == f && MultiIndexField_Inverse1(MultiIndexField(f,i)) == i); -function DeclType(Field T): ClassName; +function DeclType(Field): ClassName; type NameFamily; -function DeclName(Field T): NameFamily uses { +function DeclName(Field): NameFamily uses { axiom DeclName(alloc) == allocName; } -function FieldOfDecl(ClassName, NameFamily): Field alpha; -axiom (forall cl : ClassName, nm: NameFamily :: - {FieldOfDecl(cl, nm): Field T} - DeclType(FieldOfDecl(cl, nm): Field T) == cl && DeclName(FieldOfDecl(cl, nm): Field T) == nm); +function FieldOfDecl(ClassName, NameFamily): Field; +axiom (forall cl : ClassName, nm: NameFamily :: + {FieldOfDecl(cl, nm): Field} + DeclType(FieldOfDecl(cl, nm): Field) == cl && DeclName(FieldOfDecl(cl, nm): Field) == nm); -function $IsGhostField(Field T): bool uses { +function $IsGhostField(Field): bool uses { axiom $IsGhostField(alloc); // treat as ghost field, since it is allowed to be changed by ghost code } axiom (forall h: Heap, k: Heap :: { $HeapSuccGhost(h,k) } $HeapSuccGhost(h,k) ==> $HeapSucc(h,k) && - (forall o: ref, f: Field alpha :: { read(k, o, f) } + (forall o: ref, f: Field :: { read(k, o, f) } !$IsGhostField(f) ==> read(h, o, f) == read(k, o, f))); // --------------------------------------------------------------- @@ -558,7 +560,7 @@ axiom (forall h, k : Heap, bx : Box, t : Ty :: // No axioms for $Is and $IsBox since they don't talk about the heap. -const unique alloc: Field bool; +const unique alloc: Field; const unique allocName: NameFamily; // --------------------------------------------------------------- @@ -582,9 +584,9 @@ function {:inline} _System.real.Floor(x: real): int { Int(x) } // --------------------------------------------------------------- // -- The heap --------------------------------------------------- // --------------------------------------------------------------- -type Heap = [ref][Field alpha]Box; -function {:inline} read(H: Heap, r: ref, f: Field alpha) : alpha { $Unbox(H[r][f]) } -function {:inline} update(H:Heap, r:ref, f:Field alpha, v:alpha): Heap { H[r := H[r][f := $Box(v)]] } +type Heap = [ref][Field]Box; +function {:inline} read(H: Heap, r: ref, f: Field) : Box { H[r][f] } +function {:inline} update(H:Heap, r:ref, f: Field, v: Box) : Heap { H[r := H[r][f := v]] } function $IsGoodHeap(Heap): bool; function $IsHeapAnchor(Heap): bool; @@ -598,13 +600,13 @@ const $OneHeap: Heap uses { } function $HeapSucc(Heap, Heap): bool; -axiom (forall h: Heap, r: ref, f: Field alpha, x: alpha :: { update(h, r, f, x) } +axiom (forall h: Heap, r: ref, f: Field, x: Box :: { update(h, r, f, x) } $IsGoodHeap(update(h, r, f, x)) ==> $HeapSucc(h, update(h, r, f, x))); axiom (forall a,b,c: Heap :: { $HeapSucc(a,b), $HeapSucc(b,c) } a != c ==> $HeapSucc(a,b) && $HeapSucc(b,c) ==> $HeapSucc(a,c)); axiom (forall h: Heap, k: Heap :: { $HeapSucc(h,k) } - $HeapSucc(h,k) ==> (forall o: ref :: { read(k, o, alloc) } read(h, o, alloc) ==> read(k, o, alloc))); + $HeapSucc(h,k) ==> (forall o: ref :: { read(k, o, alloc) } $Unbox(read(h, o, alloc)) ==> $Unbox(read(k, o, alloc)))); function $HeapSuccGhost(Heap, Heap): bool; @@ -613,37 +615,37 @@ function $HeapSuccGhost(Heap, Heap): bool; // --------------------------------------------------------------- // havoc everything in $Heap, except {this}+rds+nw -procedure $YieldHavoc(this: ref, rds: Set Box, nw: Set Box); +procedure $YieldHavoc(this: ref, rds: Set, nw: Set); modifies $Heap; - ensures (forall $o: ref, $f: Field alpha :: { read($Heap, $o, $f) } - $o != null && read(old($Heap), $o, alloc) ==> + ensures (forall $o: ref, $f: Field :: { read($Heap, $o, $f) } + $o != null && $Unbox(read(old($Heap), $o, alloc)) ==> $o == this || rds[$Box($o)] || nw[$Box($o)] ==> read($Heap, $o, $f) == read(old($Heap), $o, $f)); ensures $HeapSucc(old($Heap), $Heap); // havoc everything in $Heap, except rds-modi-{this} -procedure $IterHavoc0(this: ref, rds: Set Box, modi: Set Box); +procedure $IterHavoc0(this: ref, rds: Set, modi: Set); modifies $Heap; - ensures (forall $o: ref, $f: Field alpha :: { read($Heap, $o, $f) } - $o != null && read(old($Heap), $o, alloc) ==> + ensures (forall $o: ref, $f: Field :: { read($Heap, $o, $f) } + $o != null && $Unbox(read(old($Heap), $o, alloc)) ==> rds[$Box($o)] && !modi[$Box($o)] && $o != this ==> read($Heap, $o, $f) == read(old($Heap), $o, $f)); ensures $HeapSucc(old($Heap), $Heap); // havoc $Heap at {this}+modi+nw -procedure $IterHavoc1(this: ref, modi: Set Box, nw: Set Box); +procedure $IterHavoc1(this: ref, modi: Set, nw: Set); modifies $Heap; - ensures (forall $o: ref, $f: Field alpha :: { read($Heap, $o, $f) } - $o != null && read(old($Heap), $o, alloc) ==> + ensures (forall $o: ref, $f: Field :: { read($Heap, $o, $f) } + $o != null && $Unbox(read(old($Heap), $o, alloc)) ==> read($Heap, $o, $f) == read(old($Heap), $o, $f) || $o == this || modi[$Box($o)] || nw[$Box($o)]); ensures $HeapSucc(old($Heap), $Heap); -procedure $IterCollectNewObjects(prevHeap: Heap, newHeap: Heap, this: ref, NW: Field (Set Box)) - returns (s: Set Box); +procedure $IterCollectNewObjects(prevHeap: Heap, newHeap: Heap, this: ref, NW: Field) + returns (s: Set); ensures (forall bx: Box :: { s[bx] } s[bx] <==> - (read(newHeap, this, NW) : Set Box)[bx] || - ($Unbox(bx) != null && !read(prevHeap, $Unbox(bx):ref, alloc) && read(newHeap, $Unbox(bx):ref, alloc))); + ($Unbox(read(newHeap, this, NW)) : Set)[bx] || + ($Unbox(bx) != null && !$Unbox(read(prevHeap, $Unbox(bx):ref, alloc)) && $Unbox(read(newHeap, $Unbox(bx):ref, alloc)))); // --------------------------------------------------------------- // -- Axiomatizations -------------------------------------------- @@ -653,164 +655,164 @@ procedure $IterCollectNewObjects(prevHeap: Heap, newHeap: Heap, this: ref, NW: F // -- Axiomatization of sets ------------------------------------- // --------------------------------------------------------------- -type Set T = [T]bool; +type Set = [Box]bool; -function Set#Card(Set T): int; -axiom (forall s: Set T :: { Set#Card(s) } 0 <= Set#Card(s)); +function Set#Card(Set): int; +axiom (forall s: Set :: { Set#Card(s) } 0 <= Set#Card(s)); -function Set#Empty(): Set T; -axiom (forall o: T :: { Set#Empty()[o] } !Set#Empty()[o]); -axiom (forall s: Set T :: { Set#Card(s) } +function Set#Empty(): Set; +axiom (forall o: Box :: { Set#Empty()[o] } !Set#Empty()[o]); +axiom (forall s: Set :: { Set#Card(s) } (Set#Card(s) == 0 <==> s == Set#Empty()) && - (Set#Card(s) != 0 ==> (exists x: T :: s[x]))); + (Set#Card(s) != 0 ==> (exists x: Box :: s[x]))); // the empty set could be of anything -//axiom (forall t: Ty :: { $Is(Set#Empty() : [T]bool, TSet(t)) } $Is(Set#Empty() : [T]bool, TSet(t))); +//axiom (forall t: Ty :: { $Is(Set#Empty() : [Box]bool, TSet(t)) } $Is(Set#Empty() : [Box]bool, TSet(t))); -function Set#Singleton(T): Set T; -axiom (forall r: T :: { Set#Singleton(r) } Set#Singleton(r)[r]); -axiom (forall r: T, o: T :: { Set#Singleton(r)[o] } Set#Singleton(r)[o] <==> r == o); -axiom (forall r: T :: { Set#Card(Set#Singleton(r)) } Set#Card(Set#Singleton(r)) == 1); +function Set#Singleton(Box): Set; +axiom (forall r: Box :: { Set#Singleton(r) } Set#Singleton(r)[r]); +axiom (forall r: Box, o: Box :: { Set#Singleton(r)[o] } Set#Singleton(r)[o] <==> r == o); +axiom (forall r: Box :: { Set#Card(Set#Singleton(r)) } Set#Card(Set#Singleton(r)) == 1); -function Set#UnionOne(Set T, T): Set T; -axiom (forall a: Set T, x: T, o: T :: { Set#UnionOne(a,x)[o] } +function Set#UnionOne(Set, Box): Set; +axiom (forall a: Set, x: Box, o: Box :: { Set#UnionOne(a,x)[o] } Set#UnionOne(a,x)[o] <==> o == x || a[o]); -axiom (forall a: Set T, x: T :: { Set#UnionOne(a, x) } +axiom (forall a: Set, x: Box :: { Set#UnionOne(a, x) } Set#UnionOne(a, x)[x]); -axiom (forall a: Set T, x: T, y: T :: { Set#UnionOne(a, x), a[y] } +axiom (forall a: Set, x: Box, y: Box :: { Set#UnionOne(a, x), a[y] } a[y] ==> Set#UnionOne(a, x)[y]); -axiom (forall a: Set T, x: T :: { Set#Card(Set#UnionOne(a, x)) } +axiom (forall a: Set, x: Box :: { Set#Card(Set#UnionOne(a, x)) } a[x] ==> Set#Card(Set#UnionOne(a, x)) == Set#Card(a)); -axiom (forall a: Set T, x: T :: { Set#Card(Set#UnionOne(a, x)) } +axiom (forall a: Set, x: Box :: { Set#Card(Set#UnionOne(a, x)) } !a[x] ==> Set#Card(Set#UnionOne(a, x)) == Set#Card(a) + 1); -function Set#Union(Set T, Set T): Set T; -axiom (forall a: Set T, b: Set T, o: T :: { Set#Union(a,b)[o] } +function Set#Union(Set, Set): Set; +axiom (forall a: Set, b: Set, o: Box :: { Set#Union(a,b)[o] } Set#Union(a,b)[o] <==> a[o] || b[o]); -axiom (forall a, b: Set T, y: T :: { Set#Union(a, b), a[y] } +axiom (forall a, b: Set, y: Box :: { Set#Union(a, b), a[y] } a[y] ==> Set#Union(a, b)[y]); -axiom (forall a, b: Set T, y: T :: { Set#Union(a, b), b[y] } +axiom (forall a, b: Set, y: Box :: { Set#Union(a, b), b[y] } b[y] ==> Set#Union(a, b)[y]); -axiom (forall a, b: Set T :: { Set#Union(a, b) } +axiom (forall a, b: Set :: { Set#Union(a, b) } Set#Disjoint(a, b) ==> Set#Difference(Set#Union(a, b), a) == b && Set#Difference(Set#Union(a, b), b) == a); // Follows from the general union axiom, but might be still worth including, because disjoint union is a common case: -// axiom (forall a, b: Set T :: { Set#Card(Set#Union(a, b)) } +// axiom (forall a, b: Set :: { Set#Card(Set#Union(a, b)) } // Set#Disjoint(a, b) ==> // Set#Card(Set#Union(a, b)) == Set#Card(a) + Set#Card(b)); -function Set#Intersection(Set T, Set T): Set T; -axiom (forall a: Set T, b: Set T, o: T :: { Set#Intersection(a,b)[o] } +function Set#Intersection(Set, Set): Set; +axiom (forall a: Set, b: Set, o: Box :: { Set#Intersection(a,b)[o] } Set#Intersection(a,b)[o] <==> a[o] && b[o]); -axiom (forall a, b: Set T :: { Set#Union(Set#Union(a, b), b) } +axiom (forall a, b: Set :: { Set#Union(Set#Union(a, b), b) } Set#Union(Set#Union(a, b), b) == Set#Union(a, b)); -axiom (forall a, b: Set T :: { Set#Union(a, Set#Union(a, b)) } +axiom (forall a, b: Set :: { Set#Union(a, Set#Union(a, b)) } Set#Union(a, Set#Union(a, b)) == Set#Union(a, b)); -axiom (forall a, b: Set T :: { Set#Intersection(Set#Intersection(a, b), b) } +axiom (forall a, b: Set :: { Set#Intersection(Set#Intersection(a, b), b) } Set#Intersection(Set#Intersection(a, b), b) == Set#Intersection(a, b)); -axiom (forall a, b: Set T :: { Set#Intersection(a, Set#Intersection(a, b)) } +axiom (forall a, b: Set :: { Set#Intersection(a, Set#Intersection(a, b)) } Set#Intersection(a, Set#Intersection(a, b)) == Set#Intersection(a, b)); -axiom (forall a, b: Set T :: { Set#Card(Set#Union(a, b)) }{ Set#Card(Set#Intersection(a, b)) } +axiom (forall a, b: Set :: { Set#Card(Set#Union(a, b)) }{ Set#Card(Set#Intersection(a, b)) } Set#Card(Set#Union(a, b)) + Set#Card(Set#Intersection(a, b)) == Set#Card(a) + Set#Card(b)); -function Set#Difference(Set T, Set T): Set T; -axiom (forall a: Set T, b: Set T, o: T :: { Set#Difference(a,b)[o] } +function Set#Difference(Set, Set): Set; +axiom (forall a: Set, b: Set, o: Box :: { Set#Difference(a,b)[o] } Set#Difference(a,b)[o] <==> a[o] && !b[o]); -axiom (forall a, b: Set T, y: T :: { Set#Difference(a, b), b[y] } +axiom (forall a, b: Set, y: Box :: { Set#Difference(a, b), b[y] } b[y] ==> !Set#Difference(a, b)[y] ); -axiom (forall a, b: Set T :: +axiom (forall a, b: Set :: { Set#Card(Set#Difference(a, b)) } 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))); -function Set#Subset(Set T, Set T): bool; -axiom (forall a: Set T, b: Set T :: { Set#Subset(a,b) } - Set#Subset(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] ==> b[o])); -// axiom(forall a: Set T, b: Set T :: +function Set#Subset(Set, Set): bool; +axiom (forall a: Set, b: Set :: { Set#Subset(a,b) } + Set#Subset(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] ==> b[o])); +// axiom(forall a: Set, b: Set :: // { Set#Subset(a,b), Set#Card(a), Set#Card(b) } // very restrictive trigger // Set#Subset(a,b) ==> Set#Card(a) <= Set#Card(b)); -function Set#Equal(Set T, Set T): bool; -axiom (forall a: Set T, b: Set T :: { Set#Equal(a,b) } - Set#Equal(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] <==> b[o])); -axiom (forall a: Set T, b: Set T :: { Set#Equal(a,b) } // extensionality axiom for sets +function Set#Equal(Set, Set): bool; +axiom (forall a: Set, b: Set :: { Set#Equal(a,b) } + Set#Equal(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] <==> b[o])); +axiom (forall a: Set, b: Set :: { Set#Equal(a,b) } // extensionality axiom for sets Set#Equal(a,b) ==> a == b); -function Set#Disjoint(Set T, Set T): bool; -axiom (forall a: Set T, b: Set T :: { Set#Disjoint(a,b) } - Set#Disjoint(a,b) <==> (forall o: T :: {a[o]} {b[o]} !a[o] || !b[o])); +function Set#Disjoint(Set, Set): bool; +axiom (forall a: Set, b: Set :: { Set#Disjoint(a,b) } + Set#Disjoint(a,b) <==> (forall o: Box :: {a[o]} {b[o]} !a[o] || !b[o])); // --------------------------------------------------------------- // -- Axiomatization of isets ------------------------------------- // --------------------------------------------------------------- -type ISet T = [T]bool; +type ISet = [Box]bool; -function ISet#Empty(): Set T; -axiom (forall o: T :: { ISet#Empty()[o] } !ISet#Empty()[o]); +function ISet#Empty(): Set; +axiom (forall o: Box :: { ISet#Empty()[o] } !ISet#Empty()[o]); // the empty set could be of anything -//axiom (forall t: Ty :: { $Is(ISet#Empty() : [T]bool, TISet(t)) } $Is(ISet#Empty() : [T]bool, TISet(t))); +//axiom (forall t: Ty :: { $Is(ISet#Empty() : [Box]bool, TISet(t)) } $Is(ISet#Empty() : [Box]bool, TISet(t))); -function ISet#UnionOne(ISet T, T): ISet T; -axiom (forall a: ISet T, x: T, o: T :: { ISet#UnionOne(a,x)[o] } +function ISet#UnionOne(ISet, Box): ISet; +axiom (forall a: ISet, x: Box, o: Box :: { ISet#UnionOne(a,x)[o] } ISet#UnionOne(a,x)[o] <==> o == x || a[o]); -axiom (forall a: ISet T, x: T :: { ISet#UnionOne(a, x) } +axiom (forall a: ISet, x: Box :: { ISet#UnionOne(a, x) } ISet#UnionOne(a, x)[x]); -axiom (forall a: ISet T, x: T, y: T :: { ISet#UnionOne(a, x), a[y] } +axiom (forall a: ISet, x: Box, y: Box :: { ISet#UnionOne(a, x), a[y] } a[y] ==> ISet#UnionOne(a, x)[y]); -function ISet#Union(ISet T, ISet T): ISet T; -axiom (forall a: ISet T, b: ISet T, o: T :: { ISet#Union(a,b)[o] } +function ISet#Union(ISet, ISet): ISet; +axiom (forall a: ISet, b: ISet, o: Box :: { ISet#Union(a,b)[o] } ISet#Union(a,b)[o] <==> a[o] || b[o]); -axiom (forall a, b: ISet T, y: T :: { ISet#Union(a, b), a[y] } +axiom (forall a, b: ISet, y: Box :: { ISet#Union(a, b), a[y] } a[y] ==> ISet#Union(a, b)[y]); -axiom (forall a, b: Set T, y: T :: { ISet#Union(a, b), b[y] } +axiom (forall a, b: Set, y: Box :: { ISet#Union(a, b), b[y] } b[y] ==> ISet#Union(a, b)[y]); -axiom (forall a, b: ISet T :: { ISet#Union(a, b) } +axiom (forall a, b: ISet :: { ISet#Union(a, b) } ISet#Disjoint(a, b) ==> ISet#Difference(ISet#Union(a, b), a) == b && ISet#Difference(ISet#Union(a, b), b) == a); -function ISet#Intersection(ISet T, ISet T): ISet T; -axiom (forall a: ISet T, b: ISet T, o: T :: { ISet#Intersection(a,b)[o] } +function ISet#Intersection(ISet, ISet): ISet; +axiom (forall a: ISet, b: ISet, o: Box :: { ISet#Intersection(a,b)[o] } ISet#Intersection(a,b)[o] <==> a[o] && b[o]); -axiom (forall a, b: ISet T :: { ISet#Union(ISet#Union(a, b), b) } +axiom (forall a, b: ISet :: { ISet#Union(ISet#Union(a, b), b) } ISet#Union(ISet#Union(a, b), b) == ISet#Union(a, b)); -axiom (forall a, b: Set T :: { ISet#Union(a, ISet#Union(a, b)) } +axiom (forall a, b: Set :: { ISet#Union(a, ISet#Union(a, b)) } ISet#Union(a, ISet#Union(a, b)) == ISet#Union(a, b)); -axiom (forall a, b: ISet T :: { ISet#Intersection(ISet#Intersection(a, b), b) } +axiom (forall a, b: ISet :: { ISet#Intersection(ISet#Intersection(a, b), b) } ISet#Intersection(ISet#Intersection(a, b), b) == ISet#Intersection(a, b)); -axiom (forall a, b: ISet T :: { ISet#Intersection(a, ISet#Intersection(a, b)) } +axiom (forall a, b: ISet :: { ISet#Intersection(a, ISet#Intersection(a, b)) } ISet#Intersection(a, ISet#Intersection(a, b)) == ISet#Intersection(a, b)); -function ISet#Difference(ISet T, ISet T): ISet T; -axiom (forall a: ISet T, b: ISet T, o: T :: { ISet#Difference(a,b)[o] } +function ISet#Difference(ISet, ISet): ISet; +axiom (forall a: ISet, b: ISet, o: Box :: { ISet#Difference(a,b)[o] } ISet#Difference(a,b)[o] <==> a[o] && !b[o]); -axiom (forall a, b: ISet T, y: T :: { ISet#Difference(a, b), b[y] } +axiom (forall a, b: ISet, y: Box :: { ISet#Difference(a, b), b[y] } b[y] ==> !ISet#Difference(a, b)[y] ); -function ISet#Subset(ISet T, ISet T): bool; -axiom (forall a: ISet T, b: ISet T :: { ISet#Subset(a,b) } - ISet#Subset(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] ==> b[o])); +function ISet#Subset(ISet, ISet): bool; +axiom (forall a: ISet, b: ISet :: { ISet#Subset(a,b) } + ISet#Subset(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] ==> b[o])); -function ISet#Equal(ISet T, ISet T): bool; -axiom (forall a: ISet T, b: ISet T :: { ISet#Equal(a,b) } - ISet#Equal(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] <==> b[o])); -axiom (forall a: ISet T, b: ISet T :: { ISet#Equal(a,b) } // extensionality axiom for sets +function ISet#Equal(ISet, ISet): bool; +axiom (forall a: ISet, b: ISet :: { ISet#Equal(a,b) } + ISet#Equal(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] <==> b[o])); +axiom (forall a: ISet, b: ISet :: { ISet#Equal(a,b) } // extensionality axiom for sets ISet#Equal(a,b) ==> a == b); -function ISet#Disjoint(ISet T, ISet T): bool; -axiom (forall a: ISet T, b: ISet T :: { ISet#Disjoint(a,b) } - ISet#Disjoint(a,b) <==> (forall o: T :: {a[o]} {b[o]} !a[o] || !b[o])); +function ISet#Disjoint(ISet, ISet): bool; +axiom (forall a: ISet, b: ISet :: { ISet#Disjoint(a,b) } + ISet#Disjoint(a,b) <==> (forall o: Box :: {a[o]} {b[o]} !a[o] || !b[o])); // --------------------------------------------------------------- // -- Axiomatization of multisets -------------------------------- @@ -825,71 +827,71 @@ function Math#clip(a: int): int; axiom (forall a: int :: { Math#clip(a) } 0 <= a ==> Math#clip(a) == a); axiom (forall a: int :: { Math#clip(a) } a < 0 ==> Math#clip(a) == 0); -type MultiSet T = [T]int; +type MultiSet = [Box]int; -function $IsGoodMultiSet(ms: MultiSet T): bool; +function $IsGoodMultiSet(ms: MultiSet): bool; // ints are non-negative, used after havocing, and for conversion from sequences to multisets. -axiom (forall ms: MultiSet T :: { $IsGoodMultiSet(ms) } +axiom (forall ms: MultiSet :: { $IsGoodMultiSet(ms) } $IsGoodMultiSet(ms) <==> - (forall bx: T :: { ms[bx] } 0 <= ms[bx] && ms[bx] <= MultiSet#Card(ms))); + (forall bx: Box :: { ms[bx] } 0 <= ms[bx] && ms[bx] <= MultiSet#Card(ms))); -function MultiSet#Card(MultiSet T): int; -axiom (forall s: MultiSet T :: { MultiSet#Card(s) } 0 <= MultiSet#Card(s)); -axiom (forall s: MultiSet T, x: T, n: int :: { MultiSet#Card(s[x := n]) } +function MultiSet#Card(MultiSet): int; +axiom (forall s: MultiSet :: { MultiSet#Card(s) } 0 <= MultiSet#Card(s)); +axiom (forall s: MultiSet, x: Box, n: int :: { MultiSet#Card(s[x := n]) } 0 <= n ==> MultiSet#Card(s[x := n]) == MultiSet#Card(s) - s[x] + n); -function MultiSet#Empty(): MultiSet T; -axiom (forall o: T :: { MultiSet#Empty()[o] } MultiSet#Empty()[o] == 0); -axiom (forall s: MultiSet T :: { MultiSet#Card(s) } +function MultiSet#Empty(): MultiSet; +axiom (forall o: Box :: { MultiSet#Empty()[o] } MultiSet#Empty()[o] == 0); +axiom (forall s: MultiSet :: { MultiSet#Card(s) } (MultiSet#Card(s) == 0 <==> s == MultiSet#Empty()) && - (MultiSet#Card(s) != 0 ==> (exists x: T :: 0 < s[x]))); + (MultiSet#Card(s) != 0 ==> (exists x: Box :: 0 < s[x]))); -function MultiSet#Singleton(T): MultiSet T; -axiom (forall r: T, o: T :: { MultiSet#Singleton(r)[o] } (MultiSet#Singleton(r)[o] == 1 <==> r == o) && +function MultiSet#Singleton(Box): MultiSet; +axiom (forall r: Box, o: Box :: { MultiSet#Singleton(r)[o] } (MultiSet#Singleton(r)[o] == 1 <==> r == o) && (MultiSet#Singleton(r)[o] == 0 <==> r != o)); -axiom (forall r: T :: { MultiSet#Singleton(r) } MultiSet#Singleton(r) == MultiSet#UnionOne(MultiSet#Empty(), r)); +axiom (forall r: Box :: { MultiSet#Singleton(r) } MultiSet#Singleton(r) == MultiSet#UnionOne(MultiSet#Empty(), r)); -function MultiSet#UnionOne(MultiSet T, T): MultiSet T; +function MultiSet#UnionOne(MultiSet, Box): MultiSet; // pure containment axiom (in the original multiset or is the added element) -axiom (forall a: MultiSet T, x: T, o: T :: { MultiSet#UnionOne(a,x)[o] } +axiom (forall a: MultiSet, x: Box, o: Box :: { MultiSet#UnionOne(a,x)[o] } 0 < MultiSet#UnionOne(a,x)[o] <==> o == x || 0 < a[o]); // union-ing increases count by one -axiom (forall a: MultiSet T, x: T :: { MultiSet#UnionOne(a, x) } +axiom (forall a: MultiSet, x: Box :: { MultiSet#UnionOne(a, x) } MultiSet#UnionOne(a, x)[x] == a[x] + 1); // non-decreasing -axiom (forall a: MultiSet T, x: T, y: T :: { MultiSet#UnionOne(a, x), a[y] } +axiom (forall a: MultiSet, x: Box, y: Box :: { MultiSet#UnionOne(a, x), a[y] } 0 < a[y] ==> 0 < MultiSet#UnionOne(a, x)[y]); // other elements unchanged -axiom (forall a: MultiSet T, x: T, y: T :: { MultiSet#UnionOne(a, x), a[y] } +axiom (forall a: MultiSet, x: Box, y: Box :: { MultiSet#UnionOne(a, x), a[y] } x != y ==> a[y] == MultiSet#UnionOne(a, x)[y]); -axiom (forall a: MultiSet T, x: T :: { MultiSet#Card(MultiSet#UnionOne(a, x)) } +axiom (forall a: MultiSet, x: Box :: { MultiSet#Card(MultiSet#UnionOne(a, x)) } MultiSet#Card(MultiSet#UnionOne(a, x)) == MultiSet#Card(a) + 1); -function MultiSet#Union(MultiSet T, MultiSet T): MultiSet T; +function MultiSet#Union(MultiSet, MultiSet): MultiSet; // union-ing is the sum of the contents -axiom (forall a: MultiSet T, b: MultiSet T, o: T :: { MultiSet#Union(a,b)[o] } +axiom (forall a: MultiSet, b: MultiSet, o: Box :: { MultiSet#Union(a,b)[o] } MultiSet#Union(a,b)[o] == a[o] + b[o]); -axiom (forall a: MultiSet T, b: MultiSet T :: { MultiSet#Card(MultiSet#Union(a,b)) } +axiom (forall a: MultiSet, b: MultiSet :: { MultiSet#Card(MultiSet#Union(a,b)) } MultiSet#Card(MultiSet#Union(a,b)) == MultiSet#Card(a) + MultiSet#Card(b)); -function MultiSet#Intersection(MultiSet T, MultiSet T): MultiSet T; -axiom (forall a: MultiSet T, b: MultiSet T, o: T :: { MultiSet#Intersection(a,b)[o] } +function MultiSet#Intersection(MultiSet, MultiSet): MultiSet; +axiom (forall a: MultiSet, b: MultiSet, o: Box :: { MultiSet#Intersection(a,b)[o] } MultiSet#Intersection(a,b)[o] == Math#min(a[o], b[o])); // left and right pseudo-idempotence -axiom (forall a, b: MultiSet T :: { MultiSet#Intersection(MultiSet#Intersection(a, b), b) } +axiom (forall a, b: MultiSet :: { MultiSet#Intersection(MultiSet#Intersection(a, b), b) } MultiSet#Intersection(MultiSet#Intersection(a, b), b) == MultiSet#Intersection(a, b)); -axiom (forall a, b: MultiSet T :: { MultiSet#Intersection(a, MultiSet#Intersection(a, b)) } +axiom (forall a, b: MultiSet :: { MultiSet#Intersection(a, MultiSet#Intersection(a, b)) } MultiSet#Intersection(a, MultiSet#Intersection(a, b)) == MultiSet#Intersection(a, b)); // multiset difference, a - b. clip() makes it positive. -function MultiSet#Difference(MultiSet T, MultiSet T): MultiSet T; -axiom (forall a: MultiSet T, b: MultiSet T, o: T :: { MultiSet#Difference(a,b)[o] } +function MultiSet#Difference(MultiSet, MultiSet): MultiSet; +axiom (forall a: MultiSet, b: MultiSet, o: Box :: { MultiSet#Difference(a,b)[o] } MultiSet#Difference(a,b)[o] == Math#clip(a[o] - b[o])); -axiom (forall a, b: MultiSet T, y: T :: { MultiSet#Difference(a, b), b[y], a[y] } +axiom (forall a, b: MultiSet, y: Box :: { MultiSet#Difference(a, b), b[y], a[y] } a[y] <= b[y] ==> MultiSet#Difference(a, b)[y] == 0 ); -axiom (forall a, b: MultiSet T :: +axiom (forall a, b: MultiSet :: { MultiSet#Card(MultiSet#Difference(a, b)) } MultiSet#Card(MultiSet#Difference(a, b)) + MultiSet#Card(MultiSet#Difference(b, a)) + 2 * MultiSet#Card(MultiSet#Intersection(a, b)) @@ -897,203 +899,203 @@ axiom (forall a, b: MultiSet T :: MultiSet#Card(MultiSet#Difference(a, b)) == MultiSet#Card(a) - MultiSet#Card(MultiSet#Intersection(a, b))); // multiset subset means a must have at most as many of each element as b -function MultiSet#Subset(MultiSet T, MultiSet T): bool; -axiom (forall a: MultiSet T, b: MultiSet T :: { MultiSet#Subset(a,b) } - MultiSet#Subset(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] <= b[o])); +function MultiSet#Subset(MultiSet, MultiSet): bool; +axiom (forall a: MultiSet, b: MultiSet :: { MultiSet#Subset(a,b) } + MultiSet#Subset(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] <= b[o])); -function MultiSet#Equal(MultiSet T, MultiSet T): bool; -axiom (forall a: MultiSet T, b: MultiSet T :: { MultiSet#Equal(a,b) } - MultiSet#Equal(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] == b[o])); +function MultiSet#Equal(MultiSet, MultiSet): bool; +axiom (forall a: MultiSet, b: MultiSet :: { MultiSet#Equal(a,b) } + MultiSet#Equal(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] == b[o])); // extensionality axiom for multisets -axiom (forall a: MultiSet T, b: MultiSet T :: { MultiSet#Equal(a,b) } +axiom (forall a: MultiSet, b: MultiSet :: { MultiSet#Equal(a,b) } MultiSet#Equal(a,b) ==> a == b); -function MultiSet#Disjoint(MultiSet T, MultiSet T): bool; -axiom (forall a: MultiSet T, b: MultiSet T :: { MultiSet#Disjoint(a,b) } - MultiSet#Disjoint(a,b) <==> (forall o: T :: {a[o]} {b[o]} a[o] == 0 || b[o] == 0)); +function MultiSet#Disjoint(MultiSet, MultiSet): bool; +axiom (forall a: MultiSet, b: MultiSet :: { MultiSet#Disjoint(a,b) } + MultiSet#Disjoint(a,b) <==> (forall o: Box :: {a[o]} {b[o]} a[o] == 0 || b[o] == 0)); // conversion to a multiset. each element in the original set has duplicity 1. -function MultiSet#FromSet(Set T): MultiSet T; -axiom (forall s: Set T, a: T :: { MultiSet#FromSet(s)[a] } +function MultiSet#FromSet(Set): MultiSet; +axiom (forall s: Set, a: Box :: { MultiSet#FromSet(s)[a] } (MultiSet#FromSet(s)[a] == 0 <==> !s[a]) && (MultiSet#FromSet(s)[a] == 1 <==> s[a])); -axiom (forall s: Set T :: { MultiSet#Card(MultiSet#FromSet(s)) } +axiom (forall s: Set :: { MultiSet#Card(MultiSet#FromSet(s)) } MultiSet#Card(MultiSet#FromSet(s)) == Set#Card(s)); // conversion to a multiset, from a sequence. -function MultiSet#FromSeq(Seq T): MultiSet T uses { - axiom (forall :: MultiSet#FromSeq(Seq#Empty(): Seq T) == MultiSet#Empty(): MultiSet T); +function MultiSet#FromSeq(Seq): MultiSet uses { + axiom MultiSet#FromSeq(Seq#Empty(): Seq) == MultiSet#Empty(): MultiSet; } // conversion produces a good map. -axiom (forall s: Seq T :: { MultiSet#FromSeq(s) } $IsGoodMultiSet(MultiSet#FromSeq(s)) ); +axiom (forall s: Seq :: { MultiSet#FromSeq(s) } $IsGoodMultiSet(MultiSet#FromSeq(s)) ); // cardinality axiom -axiom (forall s: Seq T :: +axiom (forall s: Seq :: { MultiSet#Card(MultiSet#FromSeq(s)) } MultiSet#Card(MultiSet#FromSeq(s)) == Seq#Length(s)); // building axiom -axiom (forall s: Seq T, v: T :: +axiom (forall s: Seq, v: Box :: { MultiSet#FromSeq(Seq#Build(s, v)) } MultiSet#FromSeq(Seq#Build(s, v)) == MultiSet#UnionOne(MultiSet#FromSeq(s), v) ); // concatenation axiom -axiom (forall a: Seq T, b: Seq T :: +axiom (forall a: Seq, b: Seq :: { MultiSet#FromSeq(Seq#Append(a, b)) } MultiSet#FromSeq(Seq#Append(a, b)) == MultiSet#Union(MultiSet#FromSeq(a), MultiSet#FromSeq(b)) ); // update axiom -axiom (forall s: Seq T, i: int, v: T, x: T :: +axiom (forall s: Seq, i: int, v: Box, x: Box :: { MultiSet#FromSeq(Seq#Update(s, i, v))[x] } 0 <= i && i < Seq#Length(s) ==> MultiSet#FromSeq(Seq#Update(s, i, v))[x] == MultiSet#Union(MultiSet#Difference(MultiSet#FromSeq(s), MultiSet#Singleton(Seq#Index(s,i))), MultiSet#Singleton(v))[x] ); // i.e. MS(Update(s, i, v)) == MS(s) - {{s[i]}} + {{v}} -axiom (forall s: Seq T, x: T :: { MultiSet#FromSeq(s)[x] } +axiom (forall s: Seq, x: Box :: { MultiSet#FromSeq(s)[x] } (exists i : int :: { Seq#Index(s,i) } 0 <= i && i < Seq#Length(s) && x == Seq#Index(s,i)) <==> 0 < MultiSet#FromSeq(s)[x] ); // --------------------------------------------------------------- // -- Axiomatization of sequences -------------------------------- // --------------------------------------------------------------- -type Seq T; +type Seq; -function Seq#Length(Seq T): int; -axiom (forall s: Seq T :: { Seq#Length(s) } 0 <= Seq#Length(s)); +function Seq#Length(Seq): int; +axiom (forall s: Seq :: { Seq#Length(s) } 0 <= Seq#Length(s)); -function Seq#Empty(): Seq T uses { - axiom (forall :: { Seq#Empty(): Seq T } Seq#Length(Seq#Empty(): Seq T) == 0); +function Seq#Empty(): Seq uses { + axiom (Seq#Length(Seq#Empty(): Seq) == 0); } -axiom (forall s: Seq T :: { Seq#Length(s) } +axiom (forall s: Seq :: { Seq#Length(s) } (Seq#Length(s) == 0 ==> s == Seq#Empty()) // The following would be a nice fact to include, because it would enable verifying the // GenericPick.SeqPick* methods in Test/dafny0/SmallTests.dfy. However, it substantially // slows down performance on some other tests, including running seemingly forever on // some. -// && (Seq#Length(s) != 0 ==> (exists x: T :: Seq#Contains(s, x))) +// && (Seq#Length(s) != 0 ==> (exists x: Box :: Seq#Contains(s, x))) ); // The empty sequence $Is any type -//axiom (forall t: Ty :: {$Is(Seq#Empty(): Seq T, TSeq(t))} $Is(Seq#Empty(): Seq T, TSeq(t))); +//axiom (forall t: Ty :: {$Is(Seq#Empty(): Seq, TSeq(t))} $Is(Seq#Empty(): Seq, TSeq(t))); -function Seq#Singleton(T): Seq T; -axiom (forall t: T :: { Seq#Length(Seq#Singleton(t)) } Seq#Length(Seq#Singleton(t)) == 1); +function Seq#Singleton(Box): Seq; +axiom (forall t: Box :: { Seq#Length(Seq#Singleton(t)) } Seq#Length(Seq#Singleton(t)) == 1); -function Seq#Build(s: Seq T, val: T): Seq T; -function Seq#Build_inv0(s: Seq T) : Seq T; -function Seq#Build_inv1(s: Seq T) : T; -axiom (forall s: Seq T, val: T :: +function Seq#Build(s: Seq, val: Box): Seq; +function Seq#Build_inv0(s: Seq) : Seq; +function Seq#Build_inv1(s: Seq) : Box; +axiom (forall s: Seq, val: Box :: { Seq#Build(s, val) } Seq#Build_inv0(Seq#Build(s, val)) == s && Seq#Build_inv1(Seq#Build(s, val)) == val); -axiom (forall s: Seq T, v: T :: +axiom (forall s: Seq, v: Box :: { Seq#Build(s,v) } Seq#Length(Seq#Build(s,v)) == 1 + Seq#Length(s)); -axiom (forall s: Seq T, i: int, v: T :: { Seq#Index(Seq#Build(s,v), i) } +axiom (forall s: Seq, i: int, v: Box :: { Seq#Index(Seq#Build(s,v), i) } (i == Seq#Length(s) ==> Seq#Index(Seq#Build(s,v), i) == v) && (i != Seq#Length(s) ==> Seq#Index(Seq#Build(s,v), i) == Seq#Index(s, i))); // Build preserves $Is -axiom (forall s: Seq Box, bx: Box, t: Ty :: { $Is(Seq#Build(s,bx),TSeq(t)) } +axiom (forall s: Seq, bx: Box, t: Ty :: { $Is(Seq#Build(s,bx),TSeq(t)) } $Is(s,TSeq(t)) && $IsBox(bx,t) ==> $Is(Seq#Build(s,bx),TSeq(t))); -function Seq#Create(ty: Ty, heap: Heap, len: int, init: HandleType): Seq Box; +function Seq#Create(ty: Ty, heap: Heap, len: int, init: HandleType): Seq; axiom (forall ty: Ty, heap: Heap, len: int, init: HandleType :: - { Seq#Length(Seq#Create(ty, heap, len, init): Seq Box) } + { Seq#Length(Seq#Create(ty, heap, len, init): Seq) } $IsGoodHeap(heap) && 0 <= len ==> - Seq#Length(Seq#Create(ty, heap, len, init): Seq Box) == len); + Seq#Length(Seq#Create(ty, heap, len, init): Seq) == len); axiom (forall ty: Ty, heap: Heap, len: int, init: HandleType, i: int :: { Seq#Index(Seq#Create(ty, heap, len, init), i) } $IsGoodHeap(heap) && 0 <= i && i < len ==> Seq#Index(Seq#Create(ty, heap, len, init), i) == Apply1(TInt, ty, heap, init, $Box(i))); -function Seq#Append(Seq T, Seq T): Seq T; -axiom (forall s0: Seq T, s1: Seq T :: { Seq#Length(Seq#Append(s0,s1)) } +function Seq#Append(Seq, Seq): Seq; +axiom (forall s0: Seq, s1: Seq :: { Seq#Length(Seq#Append(s0,s1)) } Seq#Length(Seq#Append(s0,s1)) == Seq#Length(s0) + Seq#Length(s1)); -function Seq#Index(Seq T, int): T; -axiom (forall t: T :: { Seq#Index(Seq#Singleton(t), 0) } Seq#Index(Seq#Singleton(t), 0) == t); -axiom (forall s0: Seq T, s1: Seq T, n: int :: { Seq#Index(Seq#Append(s0,s1), n) } +function Seq#Index(Seq, int): Box; +axiom (forall t: Box :: { Seq#Index(Seq#Singleton(t), 0) } Seq#Index(Seq#Singleton(t), 0) == t); +axiom (forall s0: Seq, s1: Seq, n: int :: { Seq#Index(Seq#Append(s0,s1), n) } (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)))); -function Seq#Update(Seq T, int, T): Seq T; -axiom (forall s: Seq T, i: int, v: T :: { Seq#Length(Seq#Update(s,i,v)) } +function Seq#Update(Seq, int, Box): Seq; +axiom (forall s: Seq, i: int, v: Box :: { Seq#Length(Seq#Update(s,i,v)) } 0 <= i && i < Seq#Length(s) ==> Seq#Length(Seq#Update(s,i,v)) == Seq#Length(s)); -axiom (forall s: Seq T, i: int, v: T, n: int :: { Seq#Index(Seq#Update(s,i,v),n) } +axiom (forall s: Seq, i: int, v: Box, n: int :: { Seq#Index(Seq#Update(s,i,v),n) } 0 <= n && n < Seq#Length(s) ==> (i == n ==> Seq#Index(Seq#Update(s,i,v),n) == v) && (i != n ==> Seq#Index(Seq#Update(s,i,v),n) == Seq#Index(s,n))); -function Seq#Contains(Seq T, T): bool; -axiom (forall s: Seq T, x: T :: { Seq#Contains(s,x) } +function Seq#Contains(Seq, Box): bool; +axiom (forall s: Seq, x: Box :: { Seq#Contains(s,x) } Seq#Contains(s,x) <==> (exists i: int :: { Seq#Index(s,i) } 0 <= i && i < Seq#Length(s) && Seq#Index(s,i) == x)); -axiom (forall x: T :: +axiom (forall x: Box :: { Seq#Contains(Seq#Empty(), x) } !Seq#Contains(Seq#Empty(), x)); -axiom (forall s0: Seq T, s1: Seq T, x: T :: +axiom (forall s0: Seq, s1: Seq, x: Box :: { Seq#Contains(Seq#Append(s0, s1), x) } Seq#Contains(Seq#Append(s0, s1), x) <==> Seq#Contains(s0, x) || Seq#Contains(s1, x)); -axiom (forall s: Seq T, v: T, x: T :: // needed to prove things like '4 in [2,3,4]', see method TestSequences0 in SmallTests.dfy +axiom (forall s: Seq, v: Box, x: Box :: // needed to prove things like '4 in [2,3,4]', see method TestSequences0 in SmallTests.dfy { Seq#Contains(Seq#Build(s, v), x) } Seq#Contains(Seq#Build(s, v), x) <==> (v == x || Seq#Contains(s, x))); -axiom (forall s: Seq T, n: int, x: T :: +axiom (forall s: Seq, n: int, x: Box :: { Seq#Contains(Seq#Take(s, n), x) } Seq#Contains(Seq#Take(s, n), x) <==> (exists i: int :: { Seq#Index(s, i) } 0 <= i && i < n && i < Seq#Length(s) && Seq#Index(s, i) == x)); -axiom (forall s: Seq T, n: int, x: T :: +axiom (forall s: Seq, n: int, x: Box :: { Seq#Contains(Seq#Drop(s, n), x) } Seq#Contains(Seq#Drop(s, n), x) <==> (exists i: int :: { Seq#Index(s, i) } 0 <= n && n <= i && i < Seq#Length(s) && Seq#Index(s, i) == x)); -function Seq#Equal(Seq T, Seq T): bool; -axiom (forall s0: Seq T, s1: Seq T :: { Seq#Equal(s0,s1) } +function Seq#Equal(Seq, Seq): bool; +axiom (forall s0: Seq, s1: Seq :: { Seq#Equal(s0,s1) } Seq#Equal(s0,s1) <==> Seq#Length(s0) == Seq#Length(s1) && (forall j: int :: { Seq#Index(s0,j) } { Seq#Index(s1,j) } 0 <= j && j < Seq#Length(s0) ==> Seq#Index(s0,j) == Seq#Index(s1,j))); -axiom (forall a: Seq T, b: Seq T :: { Seq#Equal(a,b) } // extensionality axiom for sequences +axiom (forall a: Seq, b: Seq :: { Seq#Equal(a,b) } // extensionality axiom for sequences Seq#Equal(a,b) ==> a == b); -function Seq#SameUntil(Seq T, Seq T, int): bool; -axiom (forall s0: Seq T, s1: Seq T, n: int :: { Seq#SameUntil(s0,s1,n) } +function Seq#SameUntil(Seq, Seq, int): bool; +axiom (forall s0: Seq, s1: Seq, n: int :: { Seq#SameUntil(s0,s1,n) } Seq#SameUntil(s0,s1,n) <==> (forall j: int :: { Seq#Index(s0,j) } { Seq#Index(s1,j) } 0 <= j && j < n ==> Seq#Index(s0,j) == Seq#Index(s1,j))); -function Seq#Take(s: Seq T, howMany: int): Seq T; -axiom (forall s: Seq T, n: int :: { Seq#Length(Seq#Take(s,n)) } +function Seq#Take(s: Seq, howMany: int): Seq; +axiom (forall s: Seq, n: int :: { Seq#Length(Seq#Take(s,n)) } 0 <= n && n <= Seq#Length(s) ==> Seq#Length(Seq#Take(s,n)) == n); -axiom (forall s: Seq T, n: int, j: int :: +axiom (forall s: Seq, n: int, j: int :: {:weight 25} { Seq#Index(Seq#Take(s,n), j) } { Seq#Index(s, j), Seq#Take(s,n) } 0 <= j && j < n && j < Seq#Length(s) ==> Seq#Index(Seq#Take(s,n), j) == Seq#Index(s, j)); -function Seq#Drop(s: Seq T, howMany: int): Seq T; -axiom (forall s: Seq T, n: int :: { Seq#Length(Seq#Drop(s,n)) } +function Seq#Drop(s: Seq, howMany: int): Seq; +axiom (forall s: Seq, n: int :: { Seq#Length(Seq#Drop(s,n)) } 0 <= n && n <= Seq#Length(s) ==> Seq#Length(Seq#Drop(s,n)) == Seq#Length(s) - n); -axiom (forall s: Seq T, n: int, j: int :: +axiom (forall s: Seq, n: int, j: int :: {:weight 25} { Seq#Index(Seq#Drop(s,n), j) } 0 <= n && 0 <= j && j < Seq#Length(s)-n ==> Seq#Index(Seq#Drop(s,n), j) == Seq#Index(s, j+n)); -axiom (forall s: Seq T, n: int, k: int :: +axiom (forall s: Seq, n: int, k: int :: {:weight 25} { Seq#Index(s, k), Seq#Drop(s,n) } 0 <= n && n <= k && k < Seq#Length(s) ==> Seq#Index(Seq#Drop(s,n), k-n) == Seq#Index(s, k)); -axiom (forall s, t: Seq T, n: int :: +axiom (forall s, t: Seq, n: int :: { Seq#Take(Seq#Append(s, t), n) } { Seq#Drop(Seq#Append(s, t), n) } n == Seq#Length(s) @@ -1101,7 +1103,7 @@ axiom (forall s, t: Seq T, n: int :: Seq#Take(Seq#Append(s, t), n) == s && Seq#Drop(Seq#Append(s, t), n) == t); -function Seq#FromArray(h: Heap, a: ref): Seq Box; +function Seq#FromArray(h: Heap, a: ref): Seq; axiom (forall h: Heap, a: ref :: { Seq#Length(Seq#FromArray(h,a)) } Seq#Length(Seq#FromArray(h, a)) == _System.array.Length(a)); @@ -1112,7 +1114,7 @@ axiom (forall h: Heap, a: ref :: // the relation between the array and the sequence can be proved in either // direction { read(h, a, IndexField(i)) } - { Seq#Index(Seq#FromArray(h, a): Seq Box, i) } + { Seq#Index(Seq#FromArray(h, a): Seq, i) } 0 <= i && i < Seq#Length(Seq#FromArray(h, a)) // this will trigger the previous axiom to get a connection with _System.array.Length(a) ==> @@ -1127,47 +1129,47 @@ axiom (forall h: Heap, i: int, v: Box, a: ref :: 0 <= i && i < _System.array.Length(a) ==> Seq#FromArray(update(h, a, IndexField(i), v), a) == Seq#Update(Seq#FromArray(h, a), i, v) ); // Commutability of Take and Drop with Update. -axiom (forall s: Seq T, i: int, v: T, n: int :: +axiom (forall s: Seq, i: int, v: Box, n: int :: { Seq#Take(Seq#Update(s, i, v), n) } 0 <= i && i < n && n <= Seq#Length(s) ==> Seq#Take(Seq#Update(s, i, v), n) == Seq#Update(Seq#Take(s, n), i, v) ); -axiom (forall s: Seq T, i: int, v: T, n: int :: +axiom (forall s: Seq, i: int, v: Box, n: int :: { Seq#Take(Seq#Update(s, i, v), n) } n <= i && i < Seq#Length(s) ==> Seq#Take(Seq#Update(s, i, v), n) == Seq#Take(s, n)); -axiom (forall s: Seq T, i: int, v: T, n: int :: +axiom (forall s: Seq, i: int, v: Box, n: int :: { Seq#Drop(Seq#Update(s, i, v), n) } 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) ); -axiom (forall s: Seq T, i: int, v: T, n: int :: +axiom (forall s: Seq, i: int, v: Box, n: int :: { Seq#Drop(Seq#Update(s, i, v), n) } 0 <= i && i < n && n <= Seq#Length(s) ==> Seq#Drop(Seq#Update(s, i, v), n) == Seq#Drop(s, n)); // Extension axiom, triggers only on Takes from arrays. axiom (forall h: Heap, a: ref, n0, n1: int :: { Seq#Take(Seq#FromArray(h, a), n0), Seq#Take(Seq#FromArray(h, a), n1) } - n0 + 1 == n1 && 0 <= n0 && n1 <= _System.array.Length(a) ==> Seq#Take(Seq#FromArray(h, a), n1) == Seq#Build(Seq#Take(Seq#FromArray(h, a), n0), read(h, a, IndexField(n0): Field Box)) ); + n0 + 1 == n1 && 0 <= n0 && n1 <= _System.array.Length(a) ==> Seq#Take(Seq#FromArray(h, a), n1) == Seq#Build(Seq#Take(Seq#FromArray(h, a), n0), read(h, a, IndexField(n0): Field)) ); // drop commutes with build. -axiom (forall s: Seq T, v: T, n: int :: +axiom (forall s: Seq, v: Box, n: int :: { Seq#Drop(Seq#Build(s, v), n) } 0 <= n && n <= Seq#Length(s) ==> Seq#Drop(Seq#Build(s, v), n) == Seq#Build(Seq#Drop(s, n), v) ); -function Seq#Rank(Seq T): int; -axiom (forall s: Seq Box, i: int :: +function Seq#Rank(Seq): int; +axiom (forall s: Seq, i: int :: { DtRank($Unbox(Seq#Index(s, i)): DatatypeType) } 0 <= i && i < Seq#Length(s) ==> DtRank($Unbox(Seq#Index(s, i)): DatatypeType) < Seq#Rank(s) ); -axiom (forall s: Seq T, i: int :: +axiom (forall s: Seq, i: int :: { Seq#Rank(Seq#Drop(s, i)) } 0 < i && i <= Seq#Length(s) ==> Seq#Rank(Seq#Drop(s, i)) < Seq#Rank(s) ); -axiom (forall s: Seq T, i: int :: +axiom (forall s: Seq, i: int :: { Seq#Rank(Seq#Take(s, i)) } 0 <= i && i < Seq#Length(s) ==> Seq#Rank(Seq#Take(s, i)) < Seq#Rank(s) ); -axiom (forall s: Seq T, i: int, j: int :: +axiom (forall s: Seq, i: int, j: int :: { Seq#Rank(Seq#Append(Seq#Take(s, i), Seq#Drop(s, j))) } 0 <= i && i < j && j <= Seq#Length(s) ==> Seq#Rank(Seq#Append(Seq#Take(s, i), Seq#Drop(s, j))) < Seq#Rank(s) ); // Additional axioms about common things -axiom (forall s: Seq T, n: int :: { Seq#Drop(s, n) } +axiom (forall s: Seq, n: int :: { Seq#Drop(s, n) } n == 0 ==> Seq#Drop(s, n) == s); -axiom (forall s: Seq T, n: int :: { Seq#Take(s, n) } +axiom (forall s: Seq, n: int :: { Seq#Take(s, n) } n == 0 ==> Seq#Take(s, n) == Seq#Empty()); -axiom (forall s: Seq T, m, n: int :: { Seq#Drop(Seq#Drop(s, m), n) } +axiom (forall s: Seq, m, n: int :: { Seq#Drop(Seq#Drop(s, m), n) } 0 <= m && 0 <= n && m+n <= Seq#Length(s) ==> Seq#Drop(Seq#Drop(s, m), n) == Seq#Drop(s, m+n)); @@ -1175,39 +1177,39 @@ axiom (forall s: Seq T, m, n: int :: { Seq#Drop(Seq#Drop(s, m), n) } // -- Axiomatization of Maps ------------------------------------- // --------------------------------------------------------------- -type Map U V; +type Map; // A Map is defined by three functions, Map#Domain, Map#Elements, and #Map#Card. -function Map#Domain(Map U V) : Set U; +function Map#Domain(Map) : Set; -function Map#Elements(Map U V) : [U]V; +function Map#Elements(Map) : [Box]Box; -function Map#Card(Map U V) : int; +function Map#Card(Map) : int; -axiom (forall m: Map U V :: { Map#Card(m) } 0 <= Map#Card(m)); +axiom (forall m: Map :: { Map#Card(m) } 0 <= Map#Card(m)); -axiom (forall m: Map U V :: +axiom (forall m: Map :: { Map#Card(m) } Map#Card(m) == 0 <==> m == Map#Empty()); -axiom (forall m: Map U V :: +axiom (forall m: Map :: { Map#Domain(m) } - m == Map#Empty() || (exists k: U :: Map#Domain(m)[k])); -axiom (forall m: Map U V :: + m == Map#Empty() || (exists k: Box :: Map#Domain(m)[k])); +axiom (forall m: Map :: { Map#Values(m) } - m == Map#Empty() || (exists v: V :: Map#Values(m)[v])); -axiom (forall m: Map U V :: + m == Map#Empty() || (exists v: Box :: Map#Values(m)[v])); +axiom (forall m: Map :: { Map#Items(m) } m == Map#Empty() || (exists k, v: Box :: Map#Items(m)[$Box(#_System._tuple#2._#Make2(k, v))])); -axiom (forall m: Map U V :: +axiom (forall m: Map :: { Set#Card(Map#Domain(m)) } { Map#Card(m) } Set#Card(Map#Domain(m)) == Map#Card(m)); -axiom (forall m: Map U V :: +axiom (forall m: Map :: { Set#Card(Map#Values(m)) } { Map#Card(m) } Set#Card(Map#Values(m)) <= Map#Card(m)); -axiom (forall m: Map U V :: +axiom (forall m: Map :: { Set#Card(Map#Items(m)) } { Map#Card(m) } Set#Card(Map#Items(m)) == Map#Card(m)); @@ -1216,11 +1218,11 @@ axiom (forall m: Map U V :: // square brackets) and Map#Card, so we need to define what these mean for the Set // returned by Map#Values. -function Map#Values(Map U V) : Set V; +function Map#Values(Map) : Set; -axiom (forall m: Map U V, v: V :: { Map#Values(m)[v] } +axiom (forall m: Map, v: Box :: { Map#Values(m)[v] } Map#Values(m)[v] == - (exists u: U :: { Map#Domain(m)[u] } { Map#Elements(m)[u] } + (exists u: Box :: { Map#Domain(m)[u] } { Map#Elements(m)[u] } Map#Domain(m)[u] && v == Map#Elements(m)[u])); @@ -1233,29 +1235,29 @@ axiom (forall m: Map U V, v: V :: { Map#Values(m)[v] } // definition of Map#Items here is to be considered Dafny specific. Also, note // that it relies on the two destructors for 2-tuples. -function Map#Items(Map U V) : Set Box; +function Map#Items(Map) : Set; function #_System._tuple#2._#Make2(Box, Box) : DatatypeType; function _System.Tuple2._0(DatatypeType) : Box; function _System.Tuple2._1(DatatypeType) : Box; -axiom (forall m: Map Box Box, item: Box :: { Map#Items(m)[item] } +axiom (forall m: Map, item: Box :: { Map#Items(m)[item] } Map#Items(m)[item] <==> Map#Domain(m)[_System.Tuple2._0($Unbox(item))] && Map#Elements(m)[_System.Tuple2._0($Unbox(item))] == _System.Tuple2._1($Unbox(item))); // Here are the operations that produce Map values. -function Map#Empty(): Map U V; -axiom (forall u: U :: - { Map#Domain(Map#Empty(): Map U V)[u] } - !Map#Domain(Map#Empty(): Map U V)[u]); +function Map#Empty(): Map; +axiom (forall u: Box :: + { Map#Domain(Map#Empty(): Map)[u] } + !Map#Domain(Map#Empty(): Map)[u]); -function Map#Glue([U]bool, [U]V, Ty): Map U V; -axiom (forall a: [U]bool, b: [U]V, t: Ty :: +function Map#Glue([Box]bool, [Box]Box, Ty): Map; +axiom (forall a: [Box]bool, b: [Box]Box, t: Ty :: { Map#Domain(Map#Glue(a, b, t)) } Map#Domain(Map#Glue(a, b, t)) == a); -axiom (forall a: [U]bool, b: [U]V, t: Ty :: +axiom (forall a: [Box]bool, b: [Box]Box, t: Ty :: { Map#Elements(Map#Glue(a, b, t)) } Map#Elements(Map#Glue(a, b, t)) == b); axiom (forall a: [Box]bool, b: [Box]Box, t0, t1: Ty :: @@ -1267,87 +1269,87 @@ axiom (forall a: [Box]bool, b: [Box]Box, t0, t1: Ty :: //Build is used in displays, and for map updates -function Map#Build(Map U V, U, V): Map U V; -/*axiom (forall m: Map U V, u: U, v: V :: +function Map#Build(Map, Box, Box): Map; +/*axiom (forall m: Map, u: Box, v: Box :: { Map#Domain(Map#Build(m, u, v))[u] } { Map#Elements(Map#Build(m, u, v))[u] } Map#Domain(Map#Build(m, u, v))[u] && Map#Elements(Map#Build(m, u, v))[u] == v);*/ -axiom (forall m: Map U V, u: U, u': U, v: V :: +axiom (forall m: Map, u: Box, u': Box, v: Box :: { Map#Domain(Map#Build(m, u, v))[u'] } { Map#Elements(Map#Build(m, u, v))[u'] } (u' == u ==> Map#Domain(Map#Build(m, u, v))[u'] && Map#Elements(Map#Build(m, u, v))[u'] == v) && (u' != u ==> Map#Domain(Map#Build(m, u, v))[u'] == Map#Domain(m)[u'] && Map#Elements(Map#Build(m, u, v))[u'] == Map#Elements(m)[u'])); -axiom (forall m: Map U V, u: U, v: V :: { Map#Card(Map#Build(m, u, v)) } +axiom (forall m: Map, u: Box, v: Box :: { Map#Card(Map#Build(m, u, v)) } Map#Domain(m)[u] ==> Map#Card(Map#Build(m, u, v)) == Map#Card(m)); -axiom (forall m: Map U V, u: U, v: V :: { Map#Card(Map#Build(m, u, v)) } +axiom (forall m: Map, u: Box, v: Box :: { Map#Card(Map#Build(m, u, v)) } !Map#Domain(m)[u] ==> Map#Card(Map#Build(m, u, v)) == Map#Card(m) + 1); // Map operations -function Map#Merge(Map U V, Map U V): Map U V; -axiom (forall m: Map U V, n: Map U V :: +function Map#Merge(Map, Map): Map; +axiom (forall m: Map, n: Map :: { Map#Domain(Map#Merge(m, n)) } Map#Domain(Map#Merge(m, n)) == Set#Union(Map#Domain(m), Map#Domain(n))); -axiom (forall m: Map U V, n: Map U V, u: U :: +axiom (forall m: Map, n: Map, u: Box :: { Map#Elements(Map#Merge(m, n))[u] } Map#Domain(Map#Merge(m, n))[u] ==> (!Map#Domain(n)[u] ==> Map#Elements(Map#Merge(m, n))[u] == Map#Elements(m)[u]) && (Map#Domain(n)[u] ==> Map#Elements(Map#Merge(m, n))[u] == Map#Elements(n)[u])); -function Map#Subtract(Map U V, Set U): Map U V; -axiom (forall m: Map U V, s: Set U :: +function Map#Subtract(Map, Set): Map; +axiom (forall m: Map, s: Set :: { Map#Domain(Map#Subtract(m, s)) } Map#Domain(Map#Subtract(m, s)) == Set#Difference(Map#Domain(m), s)); -axiom (forall m: Map U V, s: Set U, u: U :: +axiom (forall m: Map, s: Set, u: Box :: { Map#Elements(Map#Subtract(m, s))[u] } Map#Domain(Map#Subtract(m, s))[u] ==> Map#Elements(Map#Subtract(m, s))[u] == Map#Elements(m)[u]); //equality for maps -function Map#Equal(Map U V, Map U V): bool; -axiom (forall m: Map U V, m': Map U V:: +function Map#Equal(Map, Map): bool; +axiom (forall m: Map, m': Map:: { Map#Equal(m, m') } - Map#Equal(m, m') <==> (forall u : U :: Map#Domain(m)[u] == Map#Domain(m')[u]) && - (forall u : U :: Map#Domain(m)[u] ==> Map#Elements(m)[u] == Map#Elements(m')[u])); + Map#Equal(m, m') <==> (forall u : Box :: Map#Domain(m)[u] == Map#Domain(m')[u]) && + (forall u : Box :: Map#Domain(m)[u] ==> Map#Elements(m)[u] == Map#Elements(m')[u])); // extensionality -axiom (forall m: Map U V, m': Map U V:: +axiom (forall m: Map, m': Map:: { Map#Equal(m, m') } Map#Equal(m, m') ==> m == m'); -function Map#Disjoint(Map U V, Map U V): bool; -axiom (forall m: Map U V, m': Map U V :: +function Map#Disjoint(Map, Map): bool; +axiom (forall m: Map, m': Map :: { Map#Disjoint(m, m') } - Map#Disjoint(m, m') <==> (forall o: U :: {Map#Domain(m)[o]} {Map#Domain(m')[o]} !Map#Domain(m)[o] || !Map#Domain(m')[o])); + Map#Disjoint(m, m') <==> (forall o: Box :: {Map#Domain(m)[o]} {Map#Domain(m')[o]} !Map#Domain(m)[o] || !Map#Domain(m')[o])); // --------------------------------------------------------------- // -- Axiomatization of IMaps ------------------------------------ // --------------------------------------------------------------- -type IMap U V; +type IMap; // A IMap is defined by two functions, Map#Domain and Map#Elements. -function IMap#Domain(IMap U V) : Set U; +function IMap#Domain(IMap) : Set; -function IMap#Elements(IMap U V) : [U]V; +function IMap#Elements(IMap) : [Box]Box; -axiom (forall m: IMap U V :: +axiom (forall m: IMap :: { IMap#Domain(m) } - m == IMap#Empty() || (exists k: U :: IMap#Domain(m)[k])); -axiom (forall m: IMap U V :: + m == IMap#Empty() || (exists k: Box :: IMap#Domain(m)[k])); +axiom (forall m: IMap :: { IMap#Values(m) } - m == IMap#Empty() || (exists v: V :: IMap#Values(m)[v])); -axiom (forall m: IMap U V :: + m == IMap#Empty() || (exists v: Box :: IMap#Values(m)[v])); +axiom (forall m: IMap :: { IMap#Items(m) } m == IMap#Empty() || (exists k, v: Box :: IMap#Items(m)[$Box(#_System._tuple#2._#Make2(k, v))])); -axiom (forall m: IMap U V :: +axiom (forall m: IMap :: { IMap#Domain(m) } m == IMap#Empty() <==> IMap#Domain(m) == ISet#Empty()); -axiom (forall m: IMap U V :: +axiom (forall m: IMap :: { IMap#Values(m) } m == IMap#Empty() <==> IMap#Values(m) == ISet#Empty()); -axiom (forall m: IMap U V :: +axiom (forall m: IMap :: { IMap#Items(m) } m == IMap#Empty() <==> IMap#Items(m) == ISet#Empty()); @@ -1356,11 +1358,11 @@ axiom (forall m: IMap U V :: // square brackets) so we need to define what these mean for the Set // returned by Map#Values. -function IMap#Values(IMap U V) : Set V; +function IMap#Values(IMap) : Set; -axiom (forall m: IMap U V, v: V :: { IMap#Values(m)[v] } +axiom (forall m: IMap, v: Box :: { IMap#Values(m)[v] } IMap#Values(m)[v] == - (exists u: U :: { IMap#Domain(m)[u] } { IMap#Elements(m)[u] } + (exists u: Box :: { IMap#Domain(m)[u] } { IMap#Elements(m)[u] } IMap#Domain(m)[u] && v == IMap#Elements(m)[u])); @@ -1373,24 +1375,24 @@ axiom (forall m: IMap U V, v: V :: { IMap#Values(m)[v] } // definition of IMap#Items here is to be considered Dafny specific. Also, note // that it relies on the two destructors for 2-tuples. -function IMap#Items(IMap U V) : Set Box; +function IMap#Items(IMap) : Set; -axiom (forall m: IMap Box Box, item: Box :: { IMap#Items(m)[item] } +axiom (forall m: IMap, item: Box :: { IMap#Items(m)[item] } IMap#Items(m)[item] <==> IMap#Domain(m)[_System.Tuple2._0($Unbox(item))] && IMap#Elements(m)[_System.Tuple2._0($Unbox(item))] == _System.Tuple2._1($Unbox(item))); // Here are the operations that produce Map values. -function IMap#Empty(): IMap U V; -axiom (forall u: U :: - { IMap#Domain(IMap#Empty(): IMap U V)[u] } - !IMap#Domain(IMap#Empty(): IMap U V)[u]); +function IMap#Empty(): IMap; +axiom (forall u: Box :: + { IMap#Domain(IMap#Empty(): IMap)[u] } + !IMap#Domain(IMap#Empty(): IMap)[u]); -function IMap#Glue([U] bool, [U]V, Ty): IMap U V; -axiom (forall a: [U]bool, b: [U]V, t: Ty :: +function IMap#Glue([Box] bool, [Box]Box, Ty): IMap; +axiom (forall a: [Box]bool, b: [Box]Box, t: Ty :: { IMap#Domain(IMap#Glue(a, b, t)) } IMap#Domain(IMap#Glue(a, b, t)) == a); -axiom (forall a: [U]bool, b: [U]V, t: Ty :: +axiom (forall a: [Box]bool, b: [Box]Box, t: Ty :: { IMap#Elements(IMap#Glue(a, b, t)) } IMap#Elements(IMap#Glue(a, b, t)) == b); axiom (forall a: [Box]bool, b: [Box]Box, t0, t1: Ty :: @@ -1401,12 +1403,12 @@ axiom (forall a: [Box]bool, b: [Box]Box, t0, t1: Ty :: $Is(Map#Glue(a, b, TIMap(t0, t1)), TIMap(t0, t1))); //Build is used in displays -function IMap#Build(IMap U V, U, V): IMap U V; -/*axiom (forall m: IMap U V, u: U, v: V :: +function IMap#Build(IMap, Box, Box): IMap; +/*axiom (forall m: IMap, u: Box, v: Box :: { IMap#Domain(IMap#Build(m, u, v))[u] } { IMap#Elements(IMap#Build(m, u, v))[u] } IMap#Domain(IMap#Build(m, u, v))[u] && IMap#Elements(IMap#Build(m, u, v))[u] == v);*/ -axiom (forall m: IMap U V, u: U, u': U, v: V :: +axiom (forall m: IMap, u: Box, u': Box, v: Box :: { IMap#Domain(IMap#Build(m, u, v))[u'] } { IMap#Elements(IMap#Build(m, u, v))[u'] } (u' == u ==> IMap#Domain(IMap#Build(m, u, v))[u'] && IMap#Elements(IMap#Build(m, u, v))[u'] == v) && @@ -1414,32 +1416,32 @@ axiom (forall m: IMap U V, u: U, u': U, v: V :: IMap#Elements(IMap#Build(m, u, v))[u'] == IMap#Elements(m)[u'])); //equality for imaps -function IMap#Equal(IMap U V, IMap U V): bool; -axiom (forall m: IMap U V, m': IMap U V:: +function IMap#Equal(IMap, IMap): bool; +axiom (forall m: IMap, m': IMap:: { IMap#Equal(m, m') } - IMap#Equal(m, m') <==> (forall u : U :: IMap#Domain(m)[u] == IMap#Domain(m')[u]) && - (forall u : U :: IMap#Domain(m)[u] ==> IMap#Elements(m)[u] == IMap#Elements(m')[u])); + IMap#Equal(m, m') <==> (forall u : Box :: IMap#Domain(m)[u] == IMap#Domain(m')[u]) && + (forall u : Box :: IMap#Domain(m)[u] ==> IMap#Elements(m)[u] == IMap#Elements(m')[u])); // extensionality -axiom (forall m: IMap U V, m': IMap U V:: +axiom (forall m: IMap, m': IMap:: { IMap#Equal(m, m') } IMap#Equal(m, m') ==> m == m'); // IMap operations -function IMap#Merge(IMap U V, IMap U V): IMap U V; -axiom (forall m: IMap U V, n: IMap U V :: +function IMap#Merge(IMap, IMap): IMap; +axiom (forall m: IMap, n: IMap :: { IMap#Domain(IMap#Merge(m, n)) } IMap#Domain(IMap#Merge(m, n)) == Set#Union(IMap#Domain(m), IMap#Domain(n))); -axiom (forall m: IMap U V, n: IMap U V, u: U :: +axiom (forall m: IMap, n: IMap, u: Box :: { IMap#Elements(IMap#Merge(m, n))[u] } IMap#Domain(IMap#Merge(m, n))[u] ==> (!IMap#Domain(n)[u] ==> IMap#Elements(IMap#Merge(m, n))[u] == IMap#Elements(m)[u]) && (IMap#Domain(n)[u] ==> IMap#Elements(IMap#Merge(m, n))[u] == IMap#Elements(n)[u])); -function IMap#Subtract(IMap U V, Set U): IMap U V; -axiom (forall m: IMap U V, s: Set U :: +function IMap#Subtract(IMap, Set): IMap; +axiom (forall m: IMap, s: Set :: { IMap#Domain(IMap#Subtract(m, s)) } IMap#Domain(IMap#Subtract(m, s)) == Set#Difference(IMap#Domain(m), s)); -axiom (forall m: IMap U V, s: Set U, u: U :: +axiom (forall m: IMap, s: Set, u: Box :: { IMap#Elements(IMap#Subtract(m, s))[u] } IMap#Domain(IMap#Subtract(m, s))[u] ==> IMap#Elements(IMap#Subtract(m, s))[u] == IMap#Elements(m)[u]); diff --git a/Source/DafnyCore/GeneratedFromDafny.cs b/Source/DafnyCore/GeneratedFromDafny.cs index 50865aa0a8..fd91b1af45 100644 --- a/Source/DafnyCore/GeneratedFromDafny.cs +++ b/Source/DafnyCore/GeneratedFromDafny.cs @@ -921,7 +921,7 @@ public static Dafny.ISequence<__T> SetToSeq<__T>(Dafny.ISet<__T> s) { goto after__ASSIGN_SUCH_THAT_0; } } - throw new System.Exception("assign-such-that search produced no value (line 7231)"); + throw new System.Exception("assign-such-that search produced no value (line 7247)"); after__ASSIGN_SUCH_THAT_0:; _105_left = Dafny.Set<__T>.Difference(_105_left, Dafny.Set<__T>.FromElements(_106_x)); xs = Dafny.Sequence<__T>.Concat(xs, Dafny.Sequence<__T>.FromElements(_106_x)); diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.BoogieFactory.cs b/Source/DafnyCore/Verifier/BoogieGenerator.BoogieFactory.cs index 70777cc1fe..36638c1bb9 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.BoogieFactory.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.BoogieFactory.cs @@ -295,30 +295,24 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan case BuiltinFunction.SetCard: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Set#Card", Bpl.Type.Int, args); case BuiltinFunction.SetEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.SetType(tok, true, typeInstantiation); + Bpl.Type resultType = predef.SetType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "Set#Empty", resultType, args), resultType); } case BuiltinFunction.SetUnionOne: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Set#UnionOne", predef.SetType(tok, true, typeInstantiation), args); + return FunctionCall(tok, "Set#UnionOne", predef.SetType, args); case BuiltinFunction.SetUnion: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Set#Union", predef.SetType(tok, true, typeInstantiation), args); + return FunctionCall(tok, "Set#Union", predef.SetType, args); case BuiltinFunction.SetIntersection: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Set#Intersection", predef.SetType(tok, true, typeInstantiation), args); + return FunctionCall(tok, "Set#Intersection", predef.SetType, args); case BuiltinFunction.SetDifference: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Set#Difference", predef.SetType(tok, true, typeInstantiation), args); + return FunctionCall(tok, "Set#Difference", predef.SetType, args); case BuiltinFunction.SetEqual: Contract.Assert(args.Length == 2); Contract.Assert(typeInstantiation == null); @@ -333,148 +327,114 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan return FunctionCall(tok, "Set#Disjoint", Bpl.Type.Bool, args); case BuiltinFunction.ISetEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.SetType(tok, false, typeInstantiation); + Bpl.Type resultType = predef.ISetType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "ISet#Empty", resultType, args), resultType); } case BuiltinFunction.ISetUnionOne: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "ISet#UnionOne", predef.SetType(tok, false, typeInstantiation), args); + return FunctionCall(tok, "ISet#UnionOne", predef.ISetType, args); case BuiltinFunction.ISetUnion: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "ISet#Union", predef.SetType(tok, false, typeInstantiation), args); + return FunctionCall(tok, "ISet#Union", predef.ISetType, args); case BuiltinFunction.ISetIntersection: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "ISet#Intersection", predef.SetType(tok, false, typeInstantiation), args); + return FunctionCall(tok, "ISet#Intersection", predef.ISetType, args); case BuiltinFunction.ISetDifference: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "ISet#Difference", predef.SetType(tok, false, typeInstantiation), args); + return FunctionCall(tok, "ISet#Difference", predef.ISetType, args); case BuiltinFunction.ISetEqual: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "ISet#Equal", Bpl.Type.Bool, args); case BuiltinFunction.ISetSubset: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "ISet#Subset", Bpl.Type.Bool, args); case BuiltinFunction.ISetDisjoint: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "ISet#Disjoint", Bpl.Type.Bool, args); case BuiltinFunction.MultiSetCard: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "MultiSet#Card", Bpl.Type.Int, args); case BuiltinFunction.MultiSetEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.MultiSetType(tok, typeInstantiation); + Bpl.Type resultType = predef.MultiSetType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "MultiSet#Empty", resultType, args), resultType); } case BuiltinFunction.MultiSetUnionOne: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#UnionOne", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#UnionOne", predef.MultiSetType, args); case BuiltinFunction.MultiSetUnion: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#Union", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#Union", predef.MultiSetType, args); case BuiltinFunction.MultiSetIntersection: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#Intersection", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#Intersection", predef.MultiSetType, args); case BuiltinFunction.MultiSetDifference: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#Difference", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#Difference", predef.MultiSetType, args); case BuiltinFunction.MultiSetEqual: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "MultiSet#Equal", Bpl.Type.Bool, args); case BuiltinFunction.MultiSetSubset: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "MultiSet#Subset", Bpl.Type.Bool, args); case BuiltinFunction.MultiSetDisjoint: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "MultiSet#Disjoint", Bpl.Type.Bool, args); case BuiltinFunction.MultiSetFromSet: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#FromSet", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#FromSet", predef.MultiSetType, args); case BuiltinFunction.MultiSetFromSeq: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "MultiSet#FromSeq", predef.MultiSetType(tok, typeInstantiation), args); + return FunctionCall(tok, "MultiSet#FromSeq", predef.MultiSetType, args); case BuiltinFunction.IsGoodMultiSet: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "$IsGoodMultiSet", Bpl.Type.Bool, args); case BuiltinFunction.SeqLength: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Seq#Length", Bpl.Type.Int, args); case BuiltinFunction.SeqEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.SeqType(tok, typeInstantiation); + Bpl.Type resultType = predef.SeqType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "Seq#Empty", resultType, args), resultType); } case BuiltinFunction.SeqBuild: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Build", predef.SeqType(tok, typeInstantiation), args); + return FunctionCall(tok, "Seq#Build", predef.SeqType, args); case BuiltinFunction.SeqAppend: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Append", predef.SeqType(tok, typeInstantiation), args); + return FunctionCall(tok, "Seq#Append", predef.SeqType, args); case BuiltinFunction.SeqIndex: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Index", typeInstantiation, args); + return FunctionCall(tok, "Seq#Index", predef.BoxType, args); case BuiltinFunction.SeqUpdate: Contract.Assert(args.Length == 3); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Update", predef.SeqType(tok, typeInstantiation), args); + return FunctionCall(tok, "Seq#Update", predef.SeqType, args); case BuiltinFunction.SeqContains: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Seq#Contains", Bpl.Type.Bool, args); case BuiltinFunction.SeqDrop: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Drop", predef.SeqType(tok, typeInstantiation), args); + return FunctionCall(tok, "Seq#Drop", predef.SeqType, args); case BuiltinFunction.SeqTake: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "Seq#Take", predef.SeqType(tok, typeInstantiation), args); + return FunctionCall(tok, "Seq#Take", predef.SeqType, args); case BuiltinFunction.SeqEqual: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Seq#Equal", Bpl.Type.Bool, args); case BuiltinFunction.SeqSameUntil: Contract.Assert(args.Length == 3); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Seq#SameUntil", Bpl.Type.Bool, args); case BuiltinFunction.SeqFromArray: Contract.Assert(args.Length == 2); - Contract.Assert(typeInstantiation != null); return FunctionCall(tok, "Seq#FromArray", typeInstantiation, args); case BuiltinFunction.SeqRank: Contract.Assert(args.Length == 1); - Contract.Assert(typeInstantiation == null); return FunctionCall(tok, "Seq#Rank", Bpl.Type.Int, args); case BuiltinFunction.MapEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.MapType(tok, true, typeInstantiation, typeInstantiation); // use 'typeInstantiation' (which is really always just BoxType anyway) as both type arguments + Bpl.Type resultType = predef.MapType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "Map#Empty", resultType, args), resultType); } case BuiltinFunction.MapCard: @@ -489,7 +449,7 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan return FunctionCall(tok, "Map#Elements", typeInstantiation, args); case BuiltinFunction.MapGlue: Contract.Assert(args.Length == 3); - return FunctionCall(tok, "Map#Glue", predef.MapType(tok, true, predef.BoxType, predef.BoxType), args); + return FunctionCall(tok, "Map#Glue", predef.MapType, args); case BuiltinFunction.MapEqual: Contract.Assert(args.Length == 2); Contract.Assert(typeInstantiation == null); @@ -505,8 +465,7 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan case BuiltinFunction.IMapEmpty: { Contract.Assert(args.Length == 0); - Contract.Assert(typeInstantiation != null); - Bpl.Type resultType = predef.MapType(tok, false, typeInstantiation, typeInstantiation); // use 'typeInstantiation' (which is really always just BoxType anyway) as both type arguments + Bpl.Type resultType = predef.IMapType; return Bpl.Expr.CoerceType(tok, FunctionCall(tok, "IMap#Empty", resultType, args), resultType); } case BuiltinFunction.IMapDomain: @@ -517,7 +476,7 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan return FunctionCall(tok, "IMap#Elements", typeInstantiation, args); case BuiltinFunction.IMapGlue: Contract.Assert(args.Length == 3); - return FunctionCall(tok, "IMap#Glue", predef.MapType(tok, false, predef.BoxType, predef.BoxType), args); + return FunctionCall(tok, "IMap#Glue", predef.IMapType, args); case BuiltinFunction.IMapEqual: Contract.Assert(args.Length == 2); Contract.Assert(typeInstantiation == null); @@ -526,11 +485,11 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan case BuiltinFunction.IndexField: Contract.Assert(args.Length == 1); Contract.Assert(typeInstantiation == null); - return FunctionCall(tok, "IndexField", predef.FieldName(tok, predef.BoxType), args); + return FunctionCall(tok, "IndexField", predef.FieldName(tok), args); case BuiltinFunction.MultiIndexField: Contract.Assert(args.Length == 2); Contract.Assert(typeInstantiation == null); - return FunctionCall(tok, "MultiIndexField", predef.FieldName(tok, predef.BoxType), args); + return FunctionCall(tok, "MultiIndexField", predef.FieldName(tok), args); case BuiltinFunction.Box: Contract.Assert(args.Length == 1); @@ -582,7 +541,7 @@ Bpl.NAryExpr FunctionCall(Bpl.IToken tok, BuiltinFunction f, Bpl.Type typeInstan case BuiltinFunction.FieldOfDecl: Contract.Assert(args.Length == 2); Contract.Assert(typeInstantiation != null); - return FunctionCall(tok, "FieldOfDecl", predef.FieldName(tok, typeInstantiation), args); + return FunctionCall(tok, "FieldOfDecl", predef.FieldName(tok), args); case BuiltinFunction.FDim: Contract.Assert(args.Length == 1); Contract.Assert(typeInstantiation != null); diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.DataTypes.cs b/Source/DafnyCore/Verifier/BoogieGenerator.DataTypes.cs index 0a45f74123..da34b50da5 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.DataTypes.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.DataTypes.cs @@ -582,7 +582,7 @@ private Bpl.Function AddDataTypeConstructor(DatatypeDecl dt, DatatypeCtor ctor, bvs.Add(dVar); var ie = new Bpl.IdentifierExpr(arg.tok, dVar); var f = finite ? BuiltinFunction.MapDomain : BuiltinFunction.IMapDomain; - var domain = FunctionCall(arg.tok, f, predef.MapType(arg.tok, finite, predef.BoxType, predef.BoxType), + var domain = FunctionCall(arg.tok, f, finite ? predef.MapType : predef.IMapType, args[i]); var inDomain = Bpl.Expr.SelectTok(arg.tok, domain, FunctionCall(arg.tok, BuiltinFunction.Box, null, ie)); var lhs = FunctionCall(ctor.tok, BuiltinFunction.DtRank, null, ie); @@ -601,11 +601,11 @@ private Bpl.Function AddDataTypeConstructor(DatatypeDecl dt, DatatypeCtor ctor, bvs.Add(bxVar); var ie = new Bpl.IdentifierExpr(arg.tok, bxVar); var f = finite ? BuiltinFunction.MapDomain : BuiltinFunction.IMapDomain; - var domain = FunctionCall(arg.tok, f, predef.MapType(arg.tok, finite, predef.BoxType, predef.BoxType), + var domain = FunctionCall(arg.tok, f, finite ? predef.MapType : predef.IMapType, args[i]); var inDomain = Bpl.Expr.SelectTok(arg.tok, domain, ie); var ef = finite ? BuiltinFunction.MapElements : BuiltinFunction.IMapElements; - var element = FunctionCall(arg.tok, ef, predef.MapType(arg.tok, finite, predef.BoxType, predef.BoxType), + var element = FunctionCall(arg.tok, ef, finite ? predef.MapType : predef.IMapType, args[i]); var elmt = Bpl.Expr.SelectTok(arg.tok, element, ie); var unboxElmt = FunctionCall(arg.tok, BuiltinFunction.Unbox, predef.DatatypeType, elmt); diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Decreases.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Decreases.cs index 7856b85345..c56da2f856 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Decreases.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Decreases.cs @@ -287,8 +287,8 @@ void ComputeLessEq(IToken tok, Type ty0, Type ty1, Bpl.Expr e0, Bpl.Expr e1, out b1 = e1; } else { // for maps, compare their domains as sets - b0 = FunctionCall(tok, BuiltinFunction.MapDomain, predef.MapType(tok, true, predef.BoxType, predef.BoxType), e0); - b1 = FunctionCall(tok, BuiltinFunction.MapDomain, predef.MapType(tok, true, predef.BoxType, predef.BoxType), e1); + b0 = FunctionCall(tok, BuiltinFunction.MapDomain, predef.MapType, e0); + b1 = FunctionCall(tok, BuiltinFunction.MapDomain, predef.MapType, e1); } eq = FunctionCall(tok, BuiltinFunction.SetEqual, null, b0, b1); less = ProperSubset(tok, b0, b1); @@ -303,8 +303,8 @@ void ComputeLessEq(IToken tok, Type ty0, Type ty1, Bpl.Expr e0, Bpl.Expr e1, out } else { Contract.Assert(!((MapType)ty0).Finite); // for maps, compare their domains as sets - b0 = FunctionCall(tok, BuiltinFunction.IMapDomain, predef.MapType(tok, false, predef.BoxType, predef.BoxType), e0); - b1 = FunctionCall(tok, BuiltinFunction.IMapDomain, predef.MapType(tok, false, predef.BoxType, predef.BoxType), e1); + b0 = FunctionCall(tok, BuiltinFunction.IMapDomain, predef.MapType, e0); + b1 = FunctionCall(tok, BuiltinFunction.IMapDomain, predef.MapType, e1); } eq = FunctionCall(tok, BuiltinFunction.ISetEqual, null, b0, b1); less = Bpl.Expr.False; diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionTranslator.cs b/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionTranslator.cs index 77f255a84a..a6b6bab7db 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionTranslator.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionTranslator.cs @@ -256,9 +256,7 @@ private Boogie.IdentifierExpr Frame(IToken tok, string frameName) { Contract.Ensures(Contract.Result() != null); Contract.Ensures(Contract.Result().Type != null); - Boogie.TypeVariable alpha = new Boogie.TypeVariable(tok, "beta"); - Boogie.Type fieldAlpha = predef.FieldName(tok, alpha); - Boogie.Type ty = new Boogie.MapType(tok, new List { alpha }, new List { predef.RefType, fieldAlpha }, Boogie.Type.Bool); + Boogie.Type ty = new Boogie.MapType(tok, new List { }, new List { predef.RefType, predef.FieldName(tok) }, Boogie.Type.Bool); return new Boogie.IdentifierExpr(tok, frameName, ty); } @@ -444,7 +442,7 @@ public Boogie.Expr TrExpr(Expression expr) { } case MapDisplayExpr displayExpr: { MapDisplayExpr e = displayExpr; - Boogie.Type maptype = predef.MapType(GetToken(displayExpr), e.Finite, predef.BoxType, predef.BoxType); + Boogie.Type maptype = e.Finite ? predef.MapType : predef.IMapType; Boogie.Expr s = BoogieGenerator.FunctionCall(GetToken(displayExpr), e.Finite ? BuiltinFunction.MapEmpty : BuiltinFunction.IMapEmpty, predef.BoxType); var isLit = true; foreach (ExpressionPair p in e.Elements) { @@ -486,8 +484,10 @@ public Boogie.Expr TrExpr(Expression expr) { Boogie.Expr obj = TrExpr(e.Obj); Boogie.Expr result; if (field.IsMutable) { - result = ReadHeap(GetToken(expr), HeapExpr, obj, new Boogie.IdentifierExpr(GetToken(expr), BoogieGenerator.GetField(field)), fType); - return BoogieGenerator.CondApplyUnbox(GetToken(expr), result, field.Type, expr.Type); + var tok = GetToken(expr); + result = BoogieGenerator.ReadHeap(tok, HeapExpr, obj, new Boogie.IdentifierExpr(GetToken(expr), BoogieGenerator.GetField(field))); + result = fType == predef.BoxType ? result : BoogieGenerator.ApplyUnbox(tok, result, fType); + return BoogieGenerator.CondApplyUnbox(tok, result, field.Type, expr.Type); } else { result = new Boogie.NAryExpr(GetToken(expr), new Boogie.FunctionCall(BoogieGenerator.GetReadonlyField(field)), new List { obj }); @@ -552,13 +552,13 @@ public Boogie.Expr TrExpr(Expression expr) { Boogie.Expr x; if (seqType.IsArrayType) { Boogie.Expr fieldName = BoogieGenerator.FunctionCall(GetToken(selectExpr), BuiltinFunction.IndexField, null, e0); - x = ReadHeap(GetToken(selectExpr), HeapExpr, TrExpr(e.Seq), fieldName); + x = BoogieGenerator.ReadHeap(GetToken(selectExpr), HeapExpr, TrExpr(e.Seq), fieldName); } else if (seqType is SeqType) { x = BoogieGenerator.FunctionCall(GetToken(selectExpr), BuiltinFunction.SeqIndex, predef.BoxType, seq, e0); } else if (seqType is MapType) { bool finite = ((MapType)seqType).Finite; var f = finite ? BuiltinFunction.MapElements : BuiltinFunction.IMapElements; - x = BoogieGenerator.FunctionCall(GetToken(selectExpr), f, predef.MapType(GetToken(e), finite, predef.BoxType, predef.BoxType), seq); + x = BoogieGenerator.FunctionCall(GetToken(selectExpr), f, finite ? predef.MapType : predef.IMapType, seq); x = Boogie.Expr.Select(x, BoxIfNecessary(GetToken(e), e0, domainType)); } else if (seqType is MultiSetType) { x = Boogie.Expr.SelectTok(GetToken(selectExpr), TrExpr(e.Seq), BoxIfNecessary(GetToken(selectExpr), e0, domainType)); @@ -599,7 +599,7 @@ public Boogie.Expr TrExpr(Expression expr) { return BoogieGenerator.FunctionCall(GetToken(updateExpr), BuiltinFunction.SeqUpdate, predef.BoxType, seq, index, val); } else if (seqType is MapType) { MapType mt = (MapType)seqType; - Boogie.Type maptype = predef.MapType(GetToken(updateExpr), mt.Finite, predef.BoxType, predef.BoxType); + Boogie.Type maptype = mt.Finite ? predef.MapType : predef.IMapType; Boogie.Expr index = BoxIfNecessary(GetToken(updateExpr), TrExpr(e.Index), mt.Domain); Boogie.Expr val = BoxIfNecessary(GetToken(updateExpr), TrExpr(e.Value), mt.Range); return FunctionCall(GetToken(updateExpr), mt.Finite ? "Map#Build" : "IMap#Build", maptype, seq, index, val); @@ -619,7 +619,7 @@ public Boogie.Expr TrExpr(Expression expr) { Boogie.Type elType = BoogieGenerator.TrType(elmtType); Boogie.Expr fieldName = GetArrayIndexFieldName(GetToken(selectExpr), e.Indices); - Boogie.Expr x = ReadHeap(GetToken(selectExpr), HeapExpr, TrExpr(e.Array), fieldName); + Boogie.Expr x = BoogieGenerator.ReadHeap(GetToken(selectExpr), HeapExpr, TrExpr(e.Array), fieldName); if (!ModeledAsBoxType(elmtType)) { x = BoogieGenerator.FunctionCall(GetToken(selectExpr), BuiltinFunction.Unbox, elType, x); } @@ -648,13 +648,13 @@ public Boogie.Expr TrExpr(Expression expr) { } } - Func TrArg = arg => BoogieGenerator.BoxIfUnboxed(TrExpr(arg), arg.Type); + Func TrArg = arg => BoogieGenerator.BoxIfNotNormallyBoxed(arg.tok, TrExpr(arg), arg.Type); var applied = FunctionCall(GetToken(applyExpr), BoogieGenerator.Apply(arity), predef.BoxType, Concat(Map(tt.TypeArgs, BoogieGenerator.TypeToTy), Cons(HeapExpr, Cons(TrExpr(e.Function), e.Args.ConvertAll(arg => TrArg(arg)))))); - return BoogieGenerator.UnboxIfBoxed(applied, tt.Result); + return BoogieGenerator.UnboxUnlessInherentlyBoxed(applied, tt.Result); } case FunctionCallExpr callExpr: { FunctionCallExpr e = callExpr; @@ -730,7 +730,7 @@ public Boogie.Expr TrExpr(Expression expr) { case SeqConstructionExpr constructionExpr: { var e = constructionExpr; var eType = e.Type.AsSeqType.Arg.NormalizeExpand(); - return FunctionCall(GetToken(constructionExpr), "Seq#Create", predef.SeqType(GetToken(e), predef.BoxType), BoogieGenerator.TypeToTy(eType), HeapExpr, TrExpr(e.N), TrExpr(e.Initializer)); + return FunctionCall(GetToken(constructionExpr), "Seq#Create", predef.SeqType, BoogieGenerator.TypeToTy(eType), HeapExpr, TrExpr(e.N), TrExpr(e.Initializer)); } case MultiSetFormingExpr formingExpr: { MultiSetFormingExpr e = formingExpr; @@ -1190,13 +1190,13 @@ public Boogie.Expr TrExpr(Expression expr) { case BinaryExpr.ResolvedOpcode.InMap: { bool finite = e.E1.Type.AsMapType.Finite; var f = finite ? BuiltinFunction.MapDomain : BuiltinFunction.IMapDomain; - return Boogie.Expr.SelectTok(GetToken(binaryExpr), BoogieGenerator.FunctionCall(GetToken(binaryExpr), f, predef.MapType(GetToken(e), finite, predef.BoxType, predef.BoxType), e1), + return Boogie.Expr.SelectTok(GetToken(binaryExpr), BoogieGenerator.FunctionCall(GetToken(binaryExpr), f, finite ? predef.MapType : predef.IMapType, e1), BoxIfNecessary(GetToken(binaryExpr), e0, e.E0.Type)); } case BinaryExpr.ResolvedOpcode.NotInMap: { bool finite = e.E1.Type.AsMapType.Finite; var f = finite ? BuiltinFunction.MapDomain : BuiltinFunction.IMapDomain; - Boogie.Expr inMap = Boogie.Expr.SelectTok(GetToken(binaryExpr), BoogieGenerator.FunctionCall(GetToken(binaryExpr), f, predef.MapType(GetToken(e), finite, predef.BoxType, predef.BoxType), e1), + Boogie.Expr inMap = Boogie.Expr.SelectTok(GetToken(binaryExpr), BoogieGenerator.FunctionCall(GetToken(binaryExpr), f, finite ? predef.MapType : predef.IMapType, e1), BoxIfNecessary(GetToken(binaryExpr), e0, e.E0.Type)); return Boogie.Expr.Unary(GetToken(binaryExpr), UnaryOperator.Opcode.Not, inMap); } @@ -1342,7 +1342,7 @@ public Boogie.Expr TrExpr(Expression expr) { var isAlloc = BoogieGenerator.MkIsAllocBox(new Boogie.IdentifierExpr(GetToken(comprehension), yVar), bv.Type, HeapExpr); typeAntecedent = BplAnd(typeAntecedent, isAlloc); } - var yUnboxed = BoogieGenerator.UnboxIfBoxed(new Boogie.IdentifierExpr(GetToken(comprehension), yVar), bv.Type); + var yUnboxed = BoogieGenerator.UnboxUnlessInherentlyBoxed(new Boogie.IdentifierExpr(GetToken(comprehension), yVar), bv.Type); var range = BoogieGenerator.Substitute(e.Range, bv, new BoogieWrapper(yUnboxed, bv.Type)); lbody = BplAnd(typeAntecedent, TrExpr(range)); } else { @@ -1385,7 +1385,7 @@ public Boogie.Expr TrExpr(Expression expr) { if (!e.IsGeneralMapComprehension) { var bv = e.BoundVars[0]; var w = new Boogie.IdentifierExpr(GetToken(comprehension), wVar); - Boogie.Expr unboxw = BoogieGenerator.UnboxIfBoxed(w, bv.Type); + Boogie.Expr unboxw = BoogieGenerator.UnboxUnlessInherentlyBoxed(w, bv.Type); Boogie.Expr typeAntecedent = BoogieGenerator.MkIsBox(w, bv.Type); if (freeOfAlloc != null && !freeOfAlloc[0]) { var isAlloc = BoogieGenerator.MkIsAllocBox(w, bv.Type, HeapExpr); @@ -1401,7 +1401,7 @@ public Boogie.Expr TrExpr(Expression expr) { } else { var t = e.TermLeft; var w = new Boogie.IdentifierExpr(GetToken(comprehension), wVar); - Boogie.Expr unboxw = BoogieGenerator.UnboxIfBoxed(w, t.Type); + Boogie.Expr unboxw = BoogieGenerator.UnboxUnlessInherentlyBoxed(w, t.Type); Boogie.Expr typeAntecedent = BoogieGenerator.MkIsBox(w, t.Type); if (freeOfAlloc != null && !freeOfAlloc[0]) { var isAlloc = BoogieGenerator.MkIsAllocBox(w, t.Type, HeapExpr); @@ -1514,7 +1514,7 @@ private Expr TrLambdaExpr(LambdaExpr e) { select BplBoundVar(varNameGen.FreshId(string.Format("#{0}#", bv.Name)), predef.BoxType, bvars)).ToList(); var subst = e.BoundVars.Zip(ves, (bv, ve) => { - var unboxy = BoogieGenerator.UnboxIfBoxed(ve, bv.Type); + var unboxy = BoogieGenerator.UnboxUnlessInherentlyBoxed(ve, bv.Type); return new KeyValuePair(bv, new BoogieWrapper(unboxy, bv.Type)); }).ToDictionary(x => x.Key, x => x.Value); var su = new Substituter(null, subst, new Dictionary()); @@ -1525,7 +1525,7 @@ private Expr TrLambdaExpr(LambdaExpr e) { et = et.WithLayer(ly); var ebody = et.TrExpr(BoogieGenerator.Substitute(e.Body, null, subst)); - ebody = BoogieGenerator.BoxIfUnboxed(ebody, e.Body.Type); + ebody = BoogieGenerator.BoxIfNotNormallyBoxed(ebody.tok, ebody, e.Body.Type); var isBoxes = BplAnd(ves.Zip(e.BoundVars, (ve, bv) => BoogieGenerator.MkIsBox(ve, bv.Type))); var reqbody = e.Range == null @@ -1536,7 +1536,7 @@ private Expr TrLambdaExpr(LambdaExpr e) { var o = BplBoundVar(varNameGen.FreshId("#o#"), predef.RefType, rdvars); Boogie.Expr rdbody = new Boogie.LambdaExpr(GetToken(e), new List(), rdvars, null, BoogieGenerator.InRWClause(GetToken(e), o, null, e.Reads.Expressions.ConvertAll(su.SubstFrameExpr), et, null, null)); - rdbody = FunctionCall(GetToken(e), "SetRef_to_SetBox", predef.SetType(GetToken(e), true, predef.BoxType), rdbody); + rdbody = FunctionCall(GetToken(e), "SetRef_to_SetBox", predef.SetType, rdbody); return MaybeLit( BoogieGenerator.FunctionCall(GetToken(e), BuiltinFunction.AtLayer, predef.HandleType, diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionWellformed.cs b/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionWellformed.cs index 1af27e9267..e56ffe7250 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionWellformed.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.ExpressionWellformed.cs @@ -396,7 +396,7 @@ void CheckWellformedWithResult(Expression expr, WFOptions wfOptions, Bpl.Expr re e0 = etran.TrExpr(e.E0); CheckWellformed(e.E0, wfOptions, locals, builder, etran); var f = finite ? BuiltinFunction.MapDomain : BuiltinFunction.IMapDomain; - Bpl.Expr inDomain = FunctionCall(selectExpr.tok, f, predef.MapType(e.tok, finite, predef.BoxType, predef.BoxType), seq); + Bpl.Expr inDomain = FunctionCall(selectExpr.tok, f, finite ? predef.MapType : predef.IMapType, seq); inDomain = Bpl.Expr.Select(inDomain, BoxIfNecessary(e.tok, e0, e.E0.Type)); builder.Add(Assert(GetToken(expr), inDomain, new PODesc.ElementInDomain(e.Seq, e.E0), wfOptions.AssertKv)); } else if (eSeqType is MultiSetType) { @@ -636,7 +636,7 @@ void CheckWellformedWithResult(Expression expr, WFOptions wfOptions, Bpl.Expr re // the argument can't be assumed to be allocated for the old heap Type et = UserDefinedType.FromTopLevelDecl(e.tok, e.Function.EnclosingClass).Subst(e.GetTypeArgumentSubstitutions()); builder.Add(new Bpl.CommentCmd("assume allocatedness for receiver argument to function")); - builder.Add(TrAssumeCmd(e.Receiver.tok, MkIsAlloc(etran.TrExpr(e.Receiver), et, etran.HeapExpr))); + builder.Add(TrAssumeCmd(e.Receiver.tok, MkIsAllocBox(BoxIfNecessary(e.Receiver.tok, etran.TrExpr(e.Receiver), e.Receiver.Type), et, etran.HeapExpr))); } // check well-formedness of the other parameters foreach (Expression arg in e.Args) { @@ -1522,7 +1522,7 @@ private void CheckElementInit(IToken tok, bool forArray, List dims, options.AssertKv); } // Check that the values coming out of the function satisfy any appropriate subset-type constraints - var apply = UnboxIfBoxed(FunctionCall(tok, Apply(dims.Count), TrType(elementType), args), elementType); + var apply = UnboxUnlessInherentlyBoxed(FunctionCall(tok, Apply(dims.Count), TrType(elementType), args), elementType); var cre = GetSubrangeCheck(apply, sourceType.Result, elementType, out var subrangeDesc); if (cre != null) { // assert (forall i0,i1,i2,... :: @@ -1536,7 +1536,7 @@ private void CheckElementInit(IToken tok, bool forArray, List dims, // assume (forall i0,i1,i2,... :: { nw[i0,i1,i2,...] } // 0 <= i0 < ... && ... ==> nw[i0,i1,i2,...] == init.requires(i0,i1,i2,...)); var ai = ReadHeap(tok, etran.HeapExpr, nw, GetArrayIndexFieldName(tok, indices)); - var ai_prime = UnboxIfBoxed(ai, elementType); + var ai_prime = UnboxUnlessBoxType(tok, ai, elementType); var tr = new Bpl.Trigger(tok, true, new List { ai }); q = new Bpl.ForallExpr(tok, bvs, tr, Bpl.Expr.Imp(ante, Bpl.Expr.Eq(ai_prime, apply))); // TODO: use a more general Equality translation diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Fields.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Fields.cs index 98737e13dd..7ee312b18f 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Fields.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Fields.cs @@ -25,7 +25,7 @@ Bpl.Constant GetField(Field f) { Contract.Assert(fc != null); } else { // const f: Field ty; - Bpl.Type ty = predef.FieldName(f.tok, TrType(f.Type)); + Bpl.Type ty = predef.FieldName(f.tok); fc = new Bpl.Constant(f.tok, new Bpl.TypedIdent(f.tok, f.FullSanitizedName, ty), false); fields.Add(f, fc); // axiom FDim(f) == 0 && FieldOfDecl(C, name) == f && diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Functions.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Functions.cs index 2c445f9c5c..79dd1e2b15 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Functions.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Functions.cs @@ -1030,14 +1030,14 @@ public string FunctionHandle(Function f) { // Box and its [Unbox]args var fe = BplBoundVar(fm_name, predef.BoxType, bvars); lhs_args.Add(fe); - var be = UnboxIfBoxed(fe, fm.Type); + var be = UnboxUnlessInherentlyBoxed(fe, fm.Type); rhs_args.Add(be); rhs_dict[fm] = new BoogieWrapper(be, fm.Type); // args and its [Box]args var arg = BplBoundVar(fm_name, TrType(fm.Type), func_vars); func_args.Add(arg); - var boxed = BoxIfUnboxed(arg, fm.Type); + var boxed = BoxIfNotNormallyBoxed(arg.tok, arg, fm.Type); boxed_func_args.Add(boxed); } @@ -1054,7 +1054,7 @@ public string FunctionHandle(Function f) { Concat(tyargs, Cons(h, Cons(fhandle, lhs_args)))); var args_h = f.ReadsHeap ? Snoc(SnocPrevH(args), h) : args; var rhs = FunctionCall(f.tok, f.FullSanitizedName, TrType(f.ResultType), Concat(SnocSelf(args_h), rhs_args)); - var rhs_boxed = BoxIfUnboxed(rhs, f.ResultType); + var rhs_boxed = BoxIfNotNormallyBoxed(rhs.tok, rhs, f.ResultType); AddOtherDefinition(GetOrCreateFunction(f), (new Axiom(f.tok, BplForall(Concat(vars, bvars), BplTrigger(lhs), Bpl.Expr.Eq(lhs, rhs_boxed))))); @@ -1128,7 +1128,7 @@ public string FunctionHandle(Function f) { var args_h = f.ReadsHeap ? Snoc(SnocPrevH(args), h) : args; var lhs = FunctionCall(f.tok, f.FullSanitizedName, TrType(f.ResultType), Concat(SnocSelf(args_h), func_args)); var rhs = FunctionCall(f.tok, Apply(arity), TrType(f.ResultType), Concat(tyargs, Cons(h, Cons(fhandle, boxed_func_args)))); - var rhs_unboxed = UnboxIfBoxed(rhs, f.ResultType); + var rhs_unboxed = UnboxUnlessInherentlyBoxed(rhs, f.ResultType); var tr = BplTriggerHeap(this, f.tok, lhs, f.ReadsHeap ? null : h); AddOtherDefinition(GetOrCreateFunction(f), (new Axiom(f.tok, @@ -1146,7 +1146,7 @@ public string FunctionHandle(Function f) { /// heaps are well-formed and [formals are allocated AND] /// IsHeapAnchor(h0) AND HeapSucc(h0,h1) /// AND - /// (forall(alpha) o: ref, f: Field alpha :: + /// (forall o: ref, f: Field :: /// o != null [AND h0[o,alloc] AND] // note that HeapSucc(h0,h1) && h0[o,alloc] ==> h1[o,alloc] /// o in reads clause of formals in h0 /// IMPLIES h0[o,f] == h1[o,f]) @@ -1189,17 +1189,16 @@ void AddFrameAxiom(Function f) { FunctionCall(f.tok, BuiltinFunction.IsGoodHeap, null, etran0.HeapExpr), FunctionCall(f.tok, BuiltinFunction.IsGoodHeap, null, etran1.HeapExpr)); - Bpl.TypeVariable alpha = new Bpl.TypeVariable(f.tok, "alpha"); Bpl.Expr o; var oVar = BplBoundVar("$o", predef.RefType, out o); - Bpl.Expr field; var fieldVar = BplBoundVar("$f", predef.FieldName(f.tok, alpha), out field); + Bpl.Expr field; var fieldVar = BplBoundVar("$f", predef.FieldName(f.tok), out field); Bpl.Expr oNotNull = Bpl.Expr.Neq(o, predef.Null); Bpl.Expr oNotNullAlloced = oNotNull; - Bpl.Expr unchanged = Bpl.Expr.Eq(ReadHeap(f.tok, h0, o, field, alpha), ReadHeap(f.tok, h1, o, field, alpha)); + Bpl.Expr unchanged = Bpl.Expr.Eq(ReadHeap(f.tok, h0, o, field), ReadHeap(f.tok, h1, o, field)); Bpl.Expr h0IsHeapAnchor = FunctionCall(h0.tok, BuiltinFunction.IsHeapAnchor, null, h0); Bpl.Expr heapSucc = HeapSucc(h0, h1); Bpl.Expr r0 = InRWClause(f.tok, o, field, f.Reads.Expressions, etran0, null, null); - Bpl.Expr q0 = new Bpl.ForallExpr(f.tok, new List { alpha }, new List { oVar, fieldVar }, + Bpl.Expr q0 = new Bpl.ForallExpr(f.tok, new List { }, new List { oVar, fieldVar }, Bpl.Expr.Imp(Bpl.Expr.And(oNotNullAlloced, r0), unchanged)); List tyexprs; diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Iterators.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Iterators.cs index fc480f925f..84cc98baca 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Iterators.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Iterators.cs @@ -340,9 +340,9 @@ Bpl.Expr YieldCountAssumption(IteratorDecl iter, ExpressionTranslator etran) { // add the conjunct: _yieldCount == |this.ys| wh = Bpl.Expr.And(wh, Bpl.Expr.Eq(new Bpl.IdentifierExpr(iter.tok, yieldCountVariable), FunctionCall(iter.tok, BuiltinFunction.SeqLength, null, - ReadHeap(iter.tok, etran.HeapExpr, + ApplyUnbox(iter.tok, ReadHeap(iter.tok, etran.HeapExpr, new Bpl.IdentifierExpr(iter.tok, etran.This, predef.RefType), - new Bpl.IdentifierExpr(iter.tok, GetField(ys)))))); + new Bpl.IdentifierExpr(iter.tok, GetField(ys))), TrType(ys.Type))))); } return wh; } diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Methods.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Methods.cs index c1ff659c74..d8320ac1ff 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Methods.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Methods.cs @@ -323,7 +323,9 @@ private void AddInstanceFieldAllocationAxioms(Bpl.Declaration fieldDeclaration, } } else if (f.IsMutable) { // generate h[o,f] - oDotF = ReadHeap(c.tok, h, o, new Bpl.IdentifierExpr(c.tok, GetField(f)), TrType(f.Type)); + var ty = TrType(f.Type); + oDotF = ReadHeap(c.tok, h, o, new Bpl.IdentifierExpr(c.tok, GetField(f))); + oDotF = ty == predef.BoxType ? oDotF : ApplyUnbox(c.tok, oDotF, ty); bvsTypeAxiom.Add(hVar); bvsTypeAxiom.Add(oVar); bvsAllocationAxiom.Add(hVar); @@ -1142,30 +1144,29 @@ private void AddFunctionOverrideSubsetChk(Function func, BoogieStmtListBuilder b QKeyValue kv = etran.TrAttributes(func.Attributes, null); IToken tok = func.tok; - // Declare a local variable $_ReadsFrame: [ref, Field alpha]bool + // Declare a local variable $_ReadsFrame: [ref, Field]bool Bpl.IdentifierExpr traitFrame = etran.ReadsFrame(func.OverriddenFunction.tok); // this is a throw-away expression, used only to extract the type and name of the $_ReadsFrame variable traitFrame.Name = func.EnclosingClass.Name + "_" + traitFrame.Name; Contract.Assert(traitFrame.Type != null); // follows from the postcondition of ReadsFrame Bpl.LocalVariable frame = new Bpl.LocalVariable(tok, new Bpl.TypedIdent(tok, null ?? traitFrame.Name, traitFrame.Type)); localVariables.Add(frame); - // $_ReadsFrame := (lambda $o: ref, $f: Field alpha :: $o != null && $Heap[$o,alloc] ==> ($o,$f) in Modifies/Reads-Clause); - Bpl.TypeVariable alpha = new Bpl.TypeVariable(tok, "alpha"); + // $_ReadsFrame := (lambda $o: ref, $f: Field :: $o != null && $Heap[$o,alloc] ==> ($o,$f) in Modifies/Reads-Clause); Bpl.BoundVariable oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); Bpl.IdentifierExpr o = new Bpl.IdentifierExpr(tok, oVar); - Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); Bpl.IdentifierExpr f = new Bpl.IdentifierExpr(tok, fVar); Bpl.Expr ante = Bpl.Expr.And(Bpl.Expr.Neq(o, predef.Null), etran.IsAlloced(tok, o)); Bpl.Expr consequent = InRWClause(tok, o, f, traitFrameExps, etran, null, null); - Bpl.Expr lambda = new Bpl.LambdaExpr(tok, new List { alpha }, new List { oVar, fVar }, null, + Bpl.Expr lambda = new Bpl.LambdaExpr(tok, new List { }, new List { oVar, fVar }, null, Bpl.Expr.Imp(ante, consequent)); //to initialize $_ReadsFrame variable to Frame' builder.Add(Bpl.Cmd.SimpleAssign(tok, new Bpl.IdentifierExpr(tok, frame), lambda)); - // emit: assert (forall o: ref, f: Field alpha :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> $_ReadsFrame[o,f]); + // emit: assert (forall o: ref, f: Field :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> $_ReadsFrame[o,f]); Bpl.Expr oInCallee = InRWClause(tok, o, f, func.Reads.Expressions, etran, null, null); Bpl.Expr consequent2 = InRWClause(tok, o, f, traitFrameExps, etran, null, null); - Bpl.Expr q = new Bpl.ForallExpr(tok, new List { alpha }, new List { oVar, fVar }, + Bpl.Expr q = new Bpl.ForallExpr(tok, new List { }, new List { oVar, fVar }, Bpl.Expr.Imp(Bpl.Expr.And(ante, oInCallee), consequent2)); builder.Add(Assert(tok, q, new PODesc.TraitFrame(func.WhatKind, false), kv)); } @@ -1305,7 +1306,7 @@ private Boogie.Axiom FunctionOverrideAxiom(Function f, Function overridingFuncti var bv = new Boogie.BoundVariable(p.tok, new Boogie.TypedIdent(p.tok, p.AssignUniqueName(currentDeclaration.IdGenerator), TrType(pType))); forallFormals.Add(bv); var jfArg = new Boogie.IdentifierExpr(p.tok, bv); - argsJF.Add(ModeledAsBoxType(p.Type) ? BoxIfUnboxed(jfArg, pType) : jfArg); + argsJF.Add(ModeledAsBoxType(p.Type) ? BoxIfNotNormallyBoxed(p.tok, jfArg, pType) : jfArg); moreArgsCF.Add(new Boogie.IdentifierExpr(p.tok, bv)); } @@ -1358,7 +1359,7 @@ private Boogie.Axiom FunctionOverrideAxiom(Function f, Function overridingFuncti // The equality that is what it's all about var synonyms = Boogie.Expr.Eq( funcAppl, - ModeledAsBoxType(f.ResultType) ? BoxIfUnboxed(overridingFuncAppl, overridingFunction.ResultType) : overridingFuncAppl); + ModeledAsBoxType(f.ResultType) ? BoxIfNotNormallyBoxed(overridingFunction.tok, overridingFuncAppl, overridingFunction.ResultType) : overridingFuncAppl); // The axiom Boogie.Expr ax = BplForall(f.tok, new List(), forallFormals, null, tr, @@ -1547,17 +1548,16 @@ private void AddMethodOverrideFrameSubsetChk(Method m, bool isModifies, BoogieSt var kv = etran.TrAttributes(m.Attributes, null); var tok = m.tok; - var alpha = new Boogie.TypeVariable(tok, "alpha"); var oVar = new Boogie.BoundVariable(tok, new Boogie.TypedIdent(tok, "$o", predef.RefType)); var o = new Boogie.IdentifierExpr(tok, oVar); - var fVar = new Boogie.BoundVariable(tok, new Boogie.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + var fVar = new Boogie.BoundVariable(tok, new Boogie.TypedIdent(tok, "$f", predef.FieldName(tok))); var f = new Boogie.IdentifierExpr(tok, fVar); var ante = Boogie.Expr.And(Boogie.Expr.Neq(o, predef.Null), etran.IsAlloced(tok, o)); - // emit: assert (forall o: ref, f: Field alpha :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> $_Frame[o,f]); + // emit: assert (forall o: ref, f: Field :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> $_Frame[o,f]); var oInCallee = InRWClause(tok, o, f, classFrameExps, etran, null, null); var consequent2 = InRWClause(tok, o, f, traitFrameExps, etran, null, null); - var q = new Boogie.ForallExpr(tok, new List { alpha }, new List { oVar, fVar }, + var q = new Boogie.ForallExpr(tok, new List(), new List { oVar, fVar }, Boogie.Expr.Imp(Boogie.Expr.And(ante, oInCallee), consequent2)); builder.Add(Assert(m.RangeToken, q, new PODesc.TraitFrame(m.WhatKind, isModifies), kv)); } diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.TrStatement.cs b/Source/DafnyCore/Verifier/BoogieGenerator.TrStatement.cs index d6f88297b4..559570ec9c 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.TrStatement.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.TrStatement.cs @@ -1189,13 +1189,13 @@ void TrForallAssign(ForallStmt s, AssignStmt s0, // havoc $Heap; // assume $HeapSucc(oldHeap, $Heap); // (a) - // assume (forall o: ref, F: Field alpha :: + // assume (forall o: ref, F: Field :: // { $Heap[o,F] } // $Heap[o,F] = oldHeap[o,F] || // (exists x,y :: Range(x,y) && o == E(x,y) && F = f)); // assume (forall x,y :: Range ==> $Heap[ E[$Heap:=oldHeap], F] == G[$Heap:=oldHeap]); (**) // (b) - // assume (forall o: ref, F: Field alpha :: + // assume (forall o: ref, F: Field :: // { $Heap[o,F] } // $Heap[o,F] = oldHeap[o,F] || // (exists x,y :: Range(x,y) && o == A(x,y) && F = Index(I0,I1,...))); @@ -1288,18 +1288,17 @@ void TrForallAssign(ForallStmt s, AssignStmt s0, updater.Add(TrAssumeCmd(s.Tok, HeapSucc(prevHeap, etran.HeapExpr))); // Here comes: - // assume (forall o: ref, f: Field alpha :: + // assume (forall o: ref, f: Field :: // { $Heap[o,f] } // $Heap[o,f] = oldHeap[o,f] || // (exists x,y :: Range(x,y)[$Heap:=oldHeap] && // o == Object(x,y)[$Heap:=oldHeap] && f == Field(x,y)[$Heap:=oldHeap])); - Bpl.TypeVariable alpha = new Bpl.TypeVariable(s.Tok, "alpha"); Bpl.BoundVariable oVar = new Bpl.BoundVariable(s.Tok, new Bpl.TypedIdent(s.Tok, "$o", predef.RefType)); Bpl.IdentifierExpr o = new Bpl.IdentifierExpr(s.Tok, oVar); - Bpl.BoundVariable fVar = new Bpl.BoundVariable(s.Tok, new Bpl.TypedIdent(s.Tok, "$f", predef.FieldName(s.Tok, alpha))); + Bpl.BoundVariable fVar = new Bpl.BoundVariable(s.Tok, new Bpl.TypedIdent(s.Tok, "$f", predef.FieldName(s.Tok))); Bpl.IdentifierExpr f = new Bpl.IdentifierExpr(s.Tok, fVar); - Bpl.Expr heapOF = ReadHeap(s.Tok, etran.HeapExpr, o, f, alpha); - Bpl.Expr oldHeapOF = ReadHeap(s.Tok, prevHeap, o, f, alpha); + Bpl.Expr heapOF = ReadHeap(s.Tok, etran.HeapExpr, o, f); + Bpl.Expr oldHeapOF = ReadHeap(s.Tok, prevHeap, o, f); List freeOfAlloc = ComprehensionExpr.BoundedPool.HasBounds(s.Bounds, ComprehensionExpr.BoundedPool.PoolVirtues.IndependentOfAlloc_or_ExplicitAlloc); List xBvars = new List(); var xBody = etran.TrBoundVariables(s.BoundVars, xBvars, false, freeOfAlloc); @@ -1311,7 +1310,7 @@ void TrForallAssign(ForallStmt s, AssignStmt s0, Bpl.Expr xObjField = new Bpl.ExistsExpr(s.Tok, xBvars, xBody); // LL_TRIGGER Bpl.Expr body = Bpl.Expr.Or(Bpl.Expr.Eq(heapOF, oldHeapOF), xObjField); var tr = new Trigger(s.Tok, true, new List() { heapOF }); - Bpl.Expr qq = new Bpl.ForallExpr(s.Tok, new List { alpha }, new List { oVar, fVar }, null, tr, body); + Bpl.Expr qq = new Bpl.ForallExpr(s.Tok, new List { }, new List { oVar, fVar }, null, tr, body); updater.Add(TrAssumeCmd(s.Tok, qq)); if (s.EffectiveEnsuresClauses != null) { @@ -1355,9 +1354,7 @@ private Bpl.Expr TrForall_NewValueAssumption(IToken tok, List boundVar GetObjFieldDetails(lhs, prevEtran, out var obj, out var field); var xHeapOF = ReadHeap(tok, etran.HeapExpr, obj, field); - Type lhsType = lhs is MemberSelectExpr ? ((MemberSelectExpr)lhs).Type : null; - - g = CondApplyBox(rhs.tok, g, rhs.Type, lhsType); + g = BoxIfNotNormallyBoxed(rhs.tok, g, rhs.Type); Bpl.Trigger tr = null; var argsEtran = etran.WithNoLits(); @@ -2130,8 +2127,8 @@ void TrForallStmtCall(IToken tok, List boundVars, List (forall i#2: int :: true ==> LitInt(0) <= i#2 && i#2 < Seq#Length($ih#s0#0) ==> char#ToInt(_module.CharChar.MinChar($LS($LZ), $Heap, this, $ih#s0#0)) <= char#ToInt($Unbox(Seq#Index($ih#s0#0, i#2)): char))) - // TRIG (forall $ih#pat0#0: Seq Box, $ih#a0#0: Seq Box :: $Is($ih#pat0#0, TSeq(_module._default.Same0$T)) && $IsAlloc($ih#pat0#0, TSeq(_module._default.Same0$T), $initHeapForallStmt#0) && $Is($ih#a0#0, TSeq(_module._default.Same0$T)) && $IsAlloc($ih#a0#0, TSeq(_module._default.Same0$T), $initHeapForallStmt#0) && Seq#Length($ih#pat0#0) <= Seq#Length($ih#a0#0) && Seq#SameUntil($ih#pat0#0, $ih#a0#0, Seq#Length($ih#pat0#0)) && (Seq#Rank($ih#pat0#0) < Seq#Rank(pat#0) || (Seq#Rank($ih#pat0#0) == Seq#Rank(pat#0) && Seq#Rank($ih#a0#0) < Seq#Rank(a#0))) ==> _module.__default.IsRelaxedPrefixAux(_module._default.Same0$T, $LS($LZ), $Heap, $ih#pat0#0, $ih#a0#0, LitInt(1)))' + // TRIG (forall $ih#s0#0: Seq :: $Is($ih#s0#0, TSeq(TChar)) && $IsAlloc($ih#s0#0, TSeq(TChar), $initHeapForallStmt#0) && Seq#Length($ih#s0#0) != 0 && Seq#Rank($ih#s0#0) < Seq#Rank(s#0) ==> (forall i#2: int :: true ==> LitInt(0) <= i#2 && i#2 < Seq#Length($ih#s0#0) ==> char#ToInt(_module.CharChar.MinChar($LS($LZ), $Heap, this, $ih#s0#0)) <= char#ToInt($Unbox(Seq#Index($ih#s0#0, i#2)): char))) + // TRIG (forall $ih#pat0#0: Seq, $ih#a0#0: Seq :: $Is($ih#pat0#0, TSeq(_module._default.Same0$T)) && $IsAlloc($ih#pat0#0, TSeq(_module._default.Same0$T), $initHeapForallStmt#0) && $Is($ih#a0#0, TSeq(_module._default.Same0$T)) && $IsAlloc($ih#a0#0, TSeq(_module._default.Same0$T), $initHeapForallStmt#0) && Seq#Length($ih#pat0#0) <= Seq#Length($ih#a0#0) && Seq#SameUntil($ih#pat0#0, $ih#a0#0, Seq#Length($ih#pat0#0)) && (Seq#Rank($ih#pat0#0) < Seq#Rank(pat#0) || (Seq#Rank($ih#pat0#0) == Seq#Rank(pat#0) && Seq#Rank($ih#a0#0) < Seq#Rank(a#0))) ==> _module.__default.IsRelaxedPrefixAux(_module._default.Same0$T, $LS($LZ), $Heap, $ih#pat0#0, $ih#a0#0, LitInt(1)))' // TRIG (forall $ih#m0#0: DatatypeType, $ih#n0#0: DatatypeType :: $Is($ih#m0#0, Tclass._module.Nat()) && $IsAlloc($ih#m0#0, Tclass._module.Nat(), $initHeapForallStmt#0) && $Is($ih#n0#0, Tclass._module.Nat()) && $IsAlloc($ih#n0#0, Tclass._module.Nat(), $initHeapForallStmt#0) && Lit(true) && (DtRank($ih#m0#0) < DtRank(m#0) || (DtRank($ih#m0#0) == DtRank(m#0) && DtRank($ih#n0#0) < DtRank(n#0))) ==> _module.__default.mult($LS($LZ), $Heap, $ih#m0#0, _module.__default.plus($LS($LZ), $Heap, $ih#n0#0, $ih#n0#0)) == _module.__default.mult($LS($LZ), $Heap, _module.__default.plus($LS($LZ), $Heap, $ih#m0#0, $ih#m0#0), $ih#n0#0)) var qq = new Bpl.ForallExpr(tok, bvars, tr, Bpl.Expr.Imp(ante, post)); // TODO: Add a SMART_TRIGGER here. If we can't find one, abort the attempt to do induction automatically exporter.Add(TrAssumeCmd(tok, qq)); @@ -2148,7 +2145,7 @@ void RecordNewObjectsIn_New(IToken tok, IteratorDecl iter, Bpl.Expr initHeap, Bp Contract.Requires(locals != null); Contract.Requires(etran != null); // Add all newly allocated objects to the set this._new - var updatedSet = new Bpl.LocalVariable(iter.tok, new Bpl.TypedIdent(iter.tok, CurrentIdGenerator.FreshId("$iter_newUpdate"), predef.SetType(iter.tok, true, predef.BoxType))); + var updatedSet = new Bpl.LocalVariable(iter.tok, new Bpl.TypedIdent(iter.tok, CurrentIdGenerator.FreshId("$iter_newUpdate"), predef.SetType)); locals.Add(updatedSet); var updatedSetIE = new Bpl.IdentifierExpr(iter.tok, updatedSet); // call $iter_newUpdate := $IterCollectNewObjects(initHeap, $Heap, this, _new); @@ -2464,7 +2461,7 @@ void ProcessLhss(List lhss, bool rhsCanAffectPreviouslyKnownExpressi var idx = etran.TrExpr(sel.E0); idx = ConvertExpression(sel.E0.tok, idx, sel.E0.Type, Type.Int); var fieldName = SaveInTemp(FunctionCall(tok, BuiltinFunction.IndexField, null, idx), rhsCanAffectPreviouslyKnownExpressions, - "$index" + i, predef.FieldName(tok, predef.BoxType), builder, locals); + "$index" + i, predef.FieldName(tok), builder, locals); prevObj[i] = obj; prevIndex[i] = fieldName; // check that the enclosing modifies clause allows this object to be written: assert $_Frame[obj,index]); @@ -2489,7 +2486,7 @@ void ProcessLhss(List lhss, bool rhsCanAffectPreviouslyKnownExpressi var obj = SaveInTemp(etran.TrExpr(mse.Array), rhsCanAffectPreviouslyKnownExpressions, "$obj" + i, predef.RefType, builder, locals); var fieldName = SaveInTemp(etran.GetArrayIndexFieldName(mse.tok, mse.Indices), rhsCanAffectPreviouslyKnownExpressions, - "$index" + i, predef.FieldName(mse.tok, predef.BoxType), builder, locals); + "$index" + i, predef.FieldName(mse.tok), builder, locals); prevObj[i] = obj; prevIndex[i] = fieldName; builder.Add(Assert(tok, Bpl.Expr.SelectTok(tok, etran.ModifiesFrame(tok), obj, fieldName), new PODesc.Modifiable("an array element"))); @@ -2661,7 +2658,7 @@ Bpl.Expr TrAssignmentRhs(IToken tok, Bpl.IdentifierExpr bGivenLhs, IVariable lhs CheckSubrange(v.tok, EE_ii, v.Type, tRhs.EType, builder); // assume nw[ii] == EE_ii; var ai = ReadHeap(tok, etran.HeapExpr, nw, GetArrayIndexFieldName(tok, new List { Bpl.Expr.Literal(ii) })); - builder.Add(new Bpl.AssumeCmd(tok, Bpl.Expr.Eq(UnboxIfBoxed(ai, tRhs.EType), EE_ii))); + builder.Add(new Bpl.AssumeCmd(tok, Bpl.Expr.Eq(UnboxUnlessInherentlyBoxed(ai, tRhs.EType), EE_ii))); ii++; } } @@ -2669,11 +2666,11 @@ Bpl.Expr TrAssignmentRhs(IToken tok, Bpl.IdentifierExpr bGivenLhs, IVariable lhs Bpl.Cmd heapAllocationRecorder = null; if (codeContext is IteratorDecl) { var iter = (IteratorDecl)codeContext; - // $Heap[this, _new] := Set#UnionOne($Heap[this, _new], $Box($nw)); + // $Heap[this, _new] := Set#UnionOne($Heap[this, _new], $Box($nw)); var th = new Bpl.IdentifierExpr(tok, etran.This, predef.RefType); var nwField = new Bpl.IdentifierExpr(tok, GetField(iter.Member_New)); - var thisDotNew = ReadHeap(tok, etran.HeapExpr, th, nwField); - var unionOne = FunctionCall(tok, BuiltinFunction.SetUnionOne, predef.BoxType, thisDotNew, FunctionCall(tok, BuiltinFunction.Box, null, nw)); + var thisDotNew = ApplyUnbox(tok, ReadHeap(tok, etran.HeapExpr, th, nwField), predef.SetType); + var unionOne = FunctionCall(tok, BuiltinFunction.SetUnionOne, predef.BoxType, thisDotNew, ApplyBox(tok, nw)); var heapRhs = UpdateHeap(tok, etran.HeapExpr, th, nwField, unionOne); heapAllocationRecorder = Bpl.Cmd.SimpleAssign(tok, etran.HeapCastToIdentifierExpr, heapRhs); } diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.Types.cs b/Source/DafnyCore/Verifier/BoogieGenerator.Types.cs index 244cb2dd6e..1522c9e460 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.Types.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.Types.cs @@ -201,10 +201,9 @@ even fields of *unallocated* objects o are unchanged from h0 to h1 // inner forall vars var ivars = new List(); var o = BplBoundVar("o", predef.RefType, ivars); - var a = new TypeVariable(tok, "a"); - var fld = BplBoundVar("fld", predef.FieldName(tok, a), ivars); + var fld = BplBoundVar("fld", predef.FieldName(tok), ivars); - var inner_forall = new Bpl.ForallExpr(tok, Singleton(a), ivars, BplImp( + var inner_forall = new Bpl.ForallExpr(tok, new List(), ivars, BplImp( BplAnd( Bpl.Expr.Neq(o, predef.Null), // Note, the MkIsAlloc conjunct of "isness" implies that everything in the reads frame is allocated in "h0", which by HeapSucc(h0,h1) also implies the frame is allocated in "h1" @@ -213,7 +212,7 @@ even fields of *unallocated* objects o are unchanged from h0 to h1 FunctionCall(tok, BuiltinFunction.Box, null, o) }) ), - Bpl.Expr.Eq(ReadHeap(tok, h0, o, fld, a), ReadHeap(tok, h1, o, fld, a)))); + Bpl.Expr.Eq(ReadHeap(tok, h0, o, fld), ReadHeap(tok, h1, o, fld)))); Func fn = h => FunctionCall(tok, fname, Bpl.Type.Bool, Concat(types, Cons(h, Cons(f, boxes)))); @@ -1146,13 +1145,13 @@ Bpl.Expr ConvertExpression(IToken tok, Bpl.Expr r, Type fromType, Type toType) { return BoxIfNecessary(r.tok, r, fromType); } else if (toType.IsRefType) { Contract.Assert(fromType.IsTraitType); - return UnboxIfBoxed(r, toType); + return UnboxUnlessInherentlyBoxed(r, toType); } else if (toType.IsTraitType) { // cast to a non-reference trait return BoxIfNecessary(r.tok, r, fromType); } else if (fromType.IsTraitType) { // cast from a non-reference trait - return UnboxIfBoxed(r, toType); + return UnboxUnlessInherentlyBoxed(r, toType); } else if (fromType.Equals(toType)) { return r; } else { @@ -1521,4 +1520,4 @@ void AddWellformednessCheck(RedirectingTypeDecl decl) { isAllocContext = null; Reset(); } -} \ No newline at end of file +} diff --git a/Source/DafnyCore/Verifier/BoogieGenerator.cs b/Source/DafnyCore/Verifier/BoogieGenerator.cs index 82f2a38be2..e1d1f68fb6 100644 --- a/Source/DafnyCore/Verifier/BoogieGenerator.cs +++ b/Source/DafnyCore/Verifier/BoogieGenerator.cs @@ -212,14 +212,15 @@ public class PredefinedDecls { public readonly Bpl.Type CharType; public readonly Bpl.Type RefType; public readonly Bpl.Type BoxType; + public readonly Bpl.Type SetType; + public readonly Bpl.Type ISetType; + public readonly Bpl.Type MultiSetType; + public readonly Bpl.Type SeqType; + public readonly Bpl.Type MapType; + public readonly Bpl.Type IMapType; public Bpl.Type BigOrdinalType { get { return BoxType; } } - private readonly Bpl.TypeSynonymDecl setTypeCtor; - private readonly Bpl.TypeSynonymDecl isetTypeCtor; - private readonly Bpl.TypeSynonymDecl multiSetTypeCtor; - private readonly Bpl.TypeCtorDecl mapTypeCtor; - private readonly Bpl.TypeCtorDecl imapTypeCtor; public readonly Bpl.Function ArrayLength; public readonly Bpl.Function RealFloor; public readonly Bpl.Function ORDINAL_IsLimit; @@ -258,8 +259,12 @@ void ObjectInvariant() { Contract.Invariant(CharType != null); Contract.Invariant(RefType != null); Contract.Invariant(BoxType != null); - Contract.Invariant(setTypeCtor != null); - Contract.Invariant(multiSetTypeCtor != null); + Contract.Invariant(SetType != null); + Contract.Invariant(ISetType != null); + Contract.Invariant(MultiSetType != null); + Contract.Invariant(SeqType != null); + Contract.Invariant(MapType != null); + Contract.Invariant(IMapType != null); Contract.Invariant(ArrayLength != null); Contract.Invariant(RealFloor != null); Contract.Invariant(ORDINAL_IsLimit != null); @@ -291,42 +296,11 @@ void ObjectInvariant() { Contract.Invariant(AllocField != null); } - public Bpl.Type SetType(Bpl.IToken tok, bool finite, Bpl.Type ty) { + public Bpl.Type FieldName(Bpl.IToken tok) { Contract.Requires(tok != null); - Contract.Requires(ty != null); Contract.Ensures(Contract.Result() != null); - return new Bpl.TypeSynonymAnnotation(Token.NoToken, finite ? setTypeCtor : isetTypeCtor, new List { ty }); - } - - public Bpl.Type MultiSetType(Bpl.IToken tok, Bpl.Type ty) { - Contract.Requires(tok != null); - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); - - return new Bpl.TypeSynonymAnnotation(Token.NoToken, multiSetTypeCtor, new List { ty }); - } - public Bpl.Type MapType(Bpl.IToken tok, bool finite, Bpl.Type tya, Bpl.Type tyb) { - Contract.Requires(tok != null); - Contract.Requires(tya != null && tyb != null); - Contract.Ensures(Contract.Result() != null); - - return new Bpl.CtorType(Token.NoToken, finite ? mapTypeCtor : imapTypeCtor, new List { tya, tyb }); - } - - public Bpl.Type SeqType(Bpl.IToken tok, Bpl.Type ty) { - Contract.Requires(tok != null); - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); - return new Bpl.CtorType(Token.NoToken, seqTypeCtor, new List { ty }); - } - - public Bpl.Type FieldName(Bpl.IToken tok, Bpl.Type ty) { - Contract.Requires(tok != null); - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); - - return new Bpl.CtorType(tok, fieldName, new List { ty }); + return new Bpl.CtorType(tok, fieldName, new List { }); } public Bpl.IdentifierExpr Alloc(Bpl.IToken tok) { @@ -392,11 +366,12 @@ public PredefinedDecls(Bpl.TypeCtorDecl charType, Bpl.TypeCtorDecl refType, Bpl. Bpl.CtorType refT = new Bpl.CtorType(Token.NoToken, refType, new List()); this.RefType = refT; this.BoxType = new Bpl.CtorType(Token.NoToken, boxType, new List()); - this.setTypeCtor = setTypeCtor; - this.isetTypeCtor = isetTypeCtor; - this.multiSetTypeCtor = multiSetTypeCtor; - this.mapTypeCtor = mapTypeCtor; - this.imapTypeCtor = imapTypeCtor; + this.SetType = new Bpl.TypeSynonymAnnotation(Token.NoToken, setTypeCtor, new List { }); + this.ISetType = new Bpl.TypeSynonymAnnotation(Token.NoToken, setTypeCtor, new List { }); + this.MultiSetType = new Bpl.TypeSynonymAnnotation(Token.NoToken, multiSetTypeCtor, new List { }); + this.SeqType = new Bpl.CtorType(Token.NoToken, seqTypeCtor, new List { }); + this.MapType = new Bpl.CtorType(Token.NoToken, mapTypeCtor, new List { }); + this.IMapType = new Bpl.CtorType(Token.NoToken, imapTypeCtor, new List { }); this.ArrayLength = arrayLength; this.RealFloor = realFloor; this.ORDINAL_IsLimit = ORD_isLimit; @@ -1309,47 +1284,38 @@ public Bpl.Expr IsAlloced(IToken tok, Bpl.Expr heapExpr, Bpl.Expr e) { Contract.Requires(e != null); Contract.Ensures(Contract.Result() != null); - return ReadHeap(tok, heapExpr, e, predef.Alloc(tok), Bpl.Type.Bool); + return ApplyUnbox(tok, ReadHeap(tok, heapExpr, e, predef.Alloc(tok)), Bpl.Type.Bool); } - public static Bpl.Expr ReadHeap(IToken tok, Expr heap, Expr r, Expr f, Bpl.Type ty = null) { + /// + /// Returns read(heap: Heap, r: ref, f: Field) : Box. + /// + public Bpl.Expr ReadHeap(IToken tok, Expr heap, Expr r, Expr f) { Contract.Requires(tok != null); Contract.Requires(heap != null); Contract.Requires(r != null); Contract.Requires(f != null); Contract.Ensures(Contract.Result() != null); - List args = new List(); - args.Add(heap); - args.Add(r); - args.Add(f); - Bpl.Type t = (f.Type != null) ? f.Type : f.ShallowType; - Bpl.Expr readCall = - new Bpl.NAryExpr(tok, - new Bpl.FunctionCall(new Bpl.IdentifierExpr(tok, "read", t.AsCtor.Arguments[0])), - args); - // Add a type coercion if supplied - if (ty is not null) { - Contract.Assert(ty.Equals(t.AsCtor.Arguments[0])); - } - return ty is null ? readCall : Bpl.Expr.CoerceType(tok, readCall, ty); - } - - public static Bpl.NAryExpr ReadHeap(IToken tok, Expr heap, Expr r) { + var res = new Bpl.NAryExpr(tok, + new Bpl.FunctionCall(new Bpl.IdentifierExpr(tok, "read", predef.BoxType)), + new List { heap, r, f }); + res.Type = predef.BoxType; + return res; + } + + public Bpl.NAryExpr ReadHeap(IToken tok, Expr heap, Expr r) { Contract.Requires(tok != null); Contract.Requires(heap != null); Contract.Requires(r != null); Contract.Ensures(Contract.Result() != null); - - List args = new List(); - args.Add(heap); - args.Add(r); - return new Bpl.NAryExpr(tok, - new Bpl.MapSelect(tok, 1), - args); + return new Bpl.NAryExpr(tok, new Bpl.MapSelect(tok, 1), new List { heap, r }); } - public static Boogie.NAryExpr UpdateHeap(IToken tok, Expr heap, Expr r, Expr f, Expr v) { + /// + /// Returns update(h: Heap, r: ref, f: Field, v: Box) : Heap. + /// + public Boogie.NAryExpr UpdateHeap(IToken tok, Expr heap, Expr r, Expr f, Expr v) { Contract.Requires(tok != null); Contract.Requires(heap != null); Contract.Requires(r != null); @@ -1357,14 +1323,10 @@ public static Boogie.NAryExpr UpdateHeap(IToken tok, Expr heap, Expr r, Expr f, Contract.Requires(v != null); Contract.Ensures(Contract.Result() != null); - List args = new List(); - args.Add(heap); - args.Add(r); - args.Add(f); - args.Add(v); + return new Boogie.NAryExpr(tok, new Boogie.FunctionCall(new Boogie.IdentifierExpr(tok, "update", heap.Type)), - args); + new List { heap, r, f, ApplyBox(tok, v) }); } public Bpl.Expr DType(Bpl.Expr e, Bpl.Expr type) { @@ -2080,20 +2042,19 @@ void DefineFrame(IToken/*!*/ tok, Boogie.IdentifierExpr frameIdentifier, List[ref, Field alpha]bool + // Declare a local variable $_Frame: [ref, Field]bool Bpl.LocalVariable frame = new Bpl.LocalVariable(tok, new Bpl.TypedIdent(tok, name ?? frameIdentifier.Name, frameIdentifier.Type)); localVariables.Add(frame); - // $_Frame := (lambda $o: ref, $f: Field alpha :: $o != null && $Heap[$o,alloc] ==> ($o,$f) in Modifies/Reads-Clause); - // $_Frame := (lambda $o: ref, $f: Field alpha :: $o != null ==> ($o,$f) in Modifies/Reads-Clause); - Bpl.TypeVariable alpha = new Bpl.TypeVariable(tok, "alpha"); + // $_Frame := (lambda $o: ref, $f: Field :: $o != null && $Heap[$o,alloc] ==> ($o,$f) in Modifies/Reads-Clause); + // $_Frame := (lambda $o: ref, $f: Field :: $o != null ==> ($o,$f) in Modifies/Reads-Clause); Bpl.BoundVariable oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); Bpl.IdentifierExpr o = new Bpl.IdentifierExpr(tok, oVar); - Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); Bpl.IdentifierExpr f = new Bpl.IdentifierExpr(tok, fVar); Bpl.Expr oNotNull = Bpl.Expr.Neq(o, predef.Null); Bpl.Expr ante = Bpl.Expr.And(oNotNull, etran.IsAlloced(tok, o)); Bpl.Expr consequent = InRWClause(tok, o, f, frameClause, etran, null, null); - Bpl.Expr lambda = new Bpl.LambdaExpr(tok, new List { alpha }, new List { oVar, fVar }, null, + Bpl.Expr lambda = new Bpl.LambdaExpr(tok, new List { }, new List { oVar, fVar }, null, Bpl.Expr.Imp(ante, consequent)); builder.Add(Bpl.Cmd.SimpleAssign(tok, new Bpl.IdentifierExpr(tok, frame), lambda)); @@ -2122,17 +2083,16 @@ void CheckFrameSubset(IToken tok, List calleeFrame, Contract.Requires(MakeAssert != null); Contract.Requires(predef != null); - // emit: assert (forall o: ref, f: Field alpha :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> enclosingFrame[o,f]); - Bpl.TypeVariable alpha = new Bpl.TypeVariable(tok, "alpha"); - Bpl.BoundVariable oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); - Bpl.IdentifierExpr o = new Bpl.IdentifierExpr(tok, oVar); - Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); - Bpl.IdentifierExpr f = new Bpl.IdentifierExpr(tok, fVar); - Bpl.Expr ante = Bpl.Expr.And(Bpl.Expr.Neq(o, predef.Null), etran.IsAlloced(tok, o)); - Bpl.Expr oInCallee = InRWClause(tok, o, f, calleeFrame, etran, receiverReplacement, substMap); - Bpl.Expr inEnclosingFrame = Bpl.Expr.Select(enclosingFrame, o, f); + // emit: assert (forall o: ref, f: Field :: o != null && $Heap[o,alloc] && (o,f) in subFrame ==> enclosingFrame[o,f]); + var oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); + var o = new Bpl.IdentifierExpr(tok, oVar); + var fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); + var f = new Bpl.IdentifierExpr(tok, fVar); + var ante = Bpl.Expr.And(Bpl.Expr.Neq(o, predef.Null), etran.IsAlloced(tok, o)); + var oInCallee = InRWClause(tok, o, f, calleeFrame, etran, receiverReplacement, substMap); + var inEnclosingFrame = Bpl.Expr.Select(enclosingFrame, o, f); - Bpl.Expr q = new Bpl.ForallExpr(tok, new List { alpha }, new List { oVar, fVar }, + var q = new Bpl.ForallExpr(tok, new List { }, new List { oVar, fVar }, Bpl.Expr.Imp(Bpl.Expr.And(ante, oInCallee), inEnclosingFrame)); if (IsExprAlways(q, true)) { return; @@ -2150,17 +2110,16 @@ void CheckFrameEmpty(IToken tok, Contract.Requires(etran != null); Contract.Requires(predef != null); - // emit: assert (forall o: ref, f: Field alpha :: o != null && $Heap[o,alloc] ==> !frame[o,f]); - var alpha = new Bpl.TypeVariable(tok, "alpha"); + // emit: assert (forall o: ref, f: Field :: o != null && $Heap[o,alloc] ==> !frame[o,f]); var oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); var o = new Bpl.IdentifierExpr(tok, oVar); - var fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + var fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); var f = new Bpl.IdentifierExpr(tok, fVar); var ante = Bpl.Expr.And(Bpl.Expr.Neq(o, predef.Null), etran.IsAlloced(tok, o)); var inFrame = Bpl.Expr.Select(frame, o, f); var notInFrame = Bpl.Expr.Not(inFrame); - var q = new Bpl.ForallExpr(tok, new List { alpha }, new List { oVar, fVar }, + var q = new Bpl.ForallExpr(tok, new List { }, new List { oVar, fVar }, Bpl.Expr.Imp(ante, notInFrame)); if (IsExprAlways(q, true)) { return; @@ -2704,7 +2663,7 @@ void EachReferenceInFrameExpression(Expression e, List locals, Boo antecedent = Boogie.Expr.Gt(Bpl.Expr.SelectTok(e.tok, s, BoxIfNecessary(e.tok, x, type)), Boogie.Expr.Literal(0)); } else { description = "sequence element"; - obj = UnboxIfBoxed(FunctionCall(e.tok, BuiltinFunction.SeqIndex, predef.BoxType, s, x), type); + obj = UnboxUnlessInherentlyBoxed(FunctionCall(e.tok, BuiltinFunction.SeqIndex, predef.BoxType, s, x), type); antecedent = InSeqRange(e.tok, x, Type.Int, s, true, null, false); } } @@ -3098,7 +3057,7 @@ public BoilerplateTriple(IToken tok, bool isFree, Bpl.Expr expr, string errorMes // // if field granularity: // generate: - // (forall o: ref, f: Field alpha :: { $Heap[o][f] } + // (forall o: ref, f: Field :: { $Heap[o][f] } // o != null // #if use==Modifies // && old($Heap)[o][alloc] // include only in contexts that can allocate @@ -3135,27 +3094,25 @@ public BoilerplateTriple(IToken tok, bool isFree, Bpl.Expr expr, string errorMes var oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); var o = new Bpl.IdentifierExpr(tok, oVar); - Bpl.TypeVariable alpha; Bpl.Expr f; List quantifiedVars; List typeVars; Bpl.Expr heapOF; Bpl.Expr preHeapOF; if (fieldGranularity) { - alpha = new Bpl.TypeVariable(tok, "alpha"); - typeVars = new List { alpha }; - var fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + typeVars = new List { }; + var fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); f = new Bpl.IdentifierExpr(tok, fVar); quantifiedVars = new List { oVar, fVar }; - heapOF = ReadHeap(tok, etran.HeapExpr, o, f, alpha); - preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o, f, alpha); + heapOF = ReadHeap(tok, etran.HeapExpr, o, f); + preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o, f); } else { // object granularity typeVars = new List(); f = null; quantifiedVars = new List { oVar }; heapOF = ReadHeap(tok, etran.HeapExpr, o); - preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o); + preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o); // Box type is Bpl.Type.Bool, but no need to unbox for equality check } Bpl.Expr ante = Bpl.Expr.Neq(o, predef.Null); @@ -3178,25 +3135,24 @@ public BoilerplateTriple(IToken tok, bool isFree, Bpl.Expr expr, string errorMes Contract.Ensures(Contract.Result() != null); // generate: - // (forall o: ref, f: Field alpha :: { $Heap[o,f] } + // (forall o: ref, f: Field :: { $Heap[o,f] } // o != null && old($Heap)[o,alloc] ==> // $Heap[o,f] == PreHeap[o,f] || // $_Frame[o,f]) - Bpl.TypeVariable alpha = new Bpl.TypeVariable(tok, "alpha"); Bpl.BoundVariable oVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$o", predef.RefType)); Bpl.IdentifierExpr o = new Bpl.IdentifierExpr(tok, oVar); - Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok, alpha))); + Bpl.BoundVariable fVar = new Bpl.BoundVariable(tok, new Bpl.TypedIdent(tok, "$f", predef.FieldName(tok))); Bpl.IdentifierExpr f = new Bpl.IdentifierExpr(tok, fVar); - Bpl.Expr heapOF = ReadHeap(tok, etran.HeapExpr, o, f, alpha); - Bpl.Expr preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o, f, alpha); + Bpl.Expr heapOF = ReadHeap(tok, etran.HeapExpr, o, f); + Bpl.Expr preHeapOF = ReadHeap(tok, etranPre.HeapExpr, o, f); Bpl.Expr ante = Bpl.Expr.And(Bpl.Expr.Neq(o, predef.Null), etranPre.IsAlloced(tok, o)); Bpl.Expr consequent = Bpl.Expr.Eq(heapOF, preHeapOF); consequent = Bpl.Expr.Or(consequent, Bpl.Expr.SelectTok(tok, frameExpr, o, f)); Bpl.Trigger tr = new Bpl.Trigger(tok, true, new List { heapOF }); - return new Bpl.ForallExpr(tok, new List { alpha }, new List { oVar, fVar }, null, tr, Bpl.Expr.Imp(ante, consequent)); + return new Bpl.ForallExpr(tok, new List { }, new List { oVar, fVar }, null, tr, Bpl.Expr.Imp(ante, consequent)); } // ----- Type --------------------------------------------------------------------------------- // Translates a type into the representation Boogie type, @@ -3250,14 +3206,13 @@ Bpl.Type TrType(Type type) { } else if (type.IsDatatype) { return predef.DatatypeType; } else if (type is SetType) { - return predef.SetType(Token.NoToken, ((SetType)type).Finite, predef.BoxType); + return ((SetType)type).Finite ? predef.SetType : predef.ISetType; } else if (type is MultiSetType) { - return predef.MultiSetType(Token.NoToken, predef.BoxType); + return predef.MultiSetType; } else if (type is MapType) { - return predef.MapType(Token.NoToken, ((MapType)type).Finite, predef.BoxType, predef.BoxType); + return ((MapType)type).Finite ? predef.MapType : predef.IMapType; } else if (type is SeqType) { - return predef.SeqType(Token.NoToken, predef.BoxType); - + return predef.SeqType; } else { Contract.Assert(false); throw new cce.UnreachableException(); // unexpected type } @@ -3313,20 +3268,32 @@ public Bpl.Expr CondApplyUnbox(Bpl.IToken tok, Bpl.Expr e, Type fromType, Type t /// If the type is not normally boxed, insert a box around it. /// For lambda functions. /// - public Bpl.Expr BoxIfUnboxed(Bpl.Expr e, Type t) { + public Bpl.Expr BoxIfNotNormallyBoxed(Bpl.IToken tok, Bpl.Expr e, Type t) { if (!ModeledAsBoxType(t)) { - return FunctionCall(e.tok, BuiltinFunction.Box, null, e); + return ApplyBox(tok, e); } else { return e; } } + /// + /// If the passed expression is not already boxed, box it. + /// + public Bpl.Expr ApplyBox(Bpl.IToken tok, Bpl.Expr e) { + Contract.Assert(tok != null); + Contract.Assert(e != null); + if (e.Type == predef.BoxType || e is NAryExpr { Fun.FunctionName: "$Box" }) { + return e; + } + return FunctionCall(tok, BuiltinFunction.Box, null, e); + } + /// /// If the expression is boxed, but the type is not boxed, this unboxes it. /// For lambda functions. /// KRML: The name of this method is really confusing. It seems it should be named something like UnboxUnlessInherentlyBoxed. /// - public Bpl.Expr UnboxIfBoxed(Bpl.Expr e, Type t) { + public Bpl.Expr UnboxUnlessInherentlyBoxed(Bpl.Expr e, Type t) { if (!ModeledAsBoxType(t)) { return FunctionCall(e.tok, BuiltinFunction.Unbox, TrType(t), e); } else { @@ -3334,6 +3301,22 @@ public Bpl.Expr UnboxIfBoxed(Bpl.Expr e, Type t) { } } + public Expr UnboxUnlessBoxType(IToken tok, Expr e, Type type) { + return TrType(type) == predef.BoxType ? e : ApplyUnbox(tok, e, TrType(type)); + } + + /// + /// Unboxes an expression with the Box type. + /// + public Bpl.Expr ApplyUnbox(Bpl.IToken tok, Bpl.Expr e, Bpl.Type ty) { + Contract.Assert(e != null); + Contract.Assert(ty != null); + Contract.Assert(tok != null); + Contract.Assert((e.Type != null && e.Type.Equals(predef.BoxType) || + (e.ShallowType != null && e.ShallowType.Equals(predef.BoxType)))); + return FunctionCall(tok, BuiltinFunction.Unbox, ty, e); + } + public Boogie.Expr BoxifyForTraitParent(Bpl.IToken tok, Boogie.Expr obj, MemberDecl member, Type fromType) { return BoxifyForTraitParent(tok, obj, member.EnclosingClass, fromType); } @@ -4025,7 +4008,8 @@ void Check_NewRestrictions(IToken tok, Bpl.Expr obj, Field f, Bpl.Expr rhs, Boog // Assignments to an iterator _new field is only allowed to shrink the set, so: // assert Set#Subset(rhs, obj._new); var fId = new Bpl.IdentifierExpr(tok, GetField(f)); - var subset = FunctionCall(tok, BuiltinFunction.SetSubset, null, rhs, ReadHeap(tok, etran.HeapExpr, obj, fId, TrType(f.Type))); + var subset = FunctionCall(tok, BuiltinFunction.SetSubset, null, rhs, + ApplyUnbox(tok, ReadHeap(tok, etran.HeapExpr, obj, fId), predef.SetType)); builder.Add(Assert(tok, subset, new PODesc.AssignmentShrinks(f.Name))); } } diff --git a/Source/DafnyLanguageServer.Test/Performance/ThreadUsageTest.cs b/Source/DafnyLanguageServer.Test/Performance/ThreadUsageTest.cs index c84a43a5bd..ff6815aa46 100644 --- a/Source/DafnyLanguageServer.Test/Performance/ThreadUsageTest.cs +++ b/Source/DafnyLanguageServer.Test/Performance/ThreadUsageTest.cs @@ -24,10 +24,10 @@ public async Task NoExtraThreadAfterEachChange() { } var threadCountAfter = Process.GetCurrentProcess().Threads.Count; const int maxThreadCountIncrease = 5; - Assert.True(threadCountAfter - threadCountBefore < maxThreadCountIncrease); + Assert.InRange(threadCountAfter - threadCountBefore, -maxThreadCountIncrease, maxThreadCountIncrease); } public ThreadUsageTest(ITestOutputHelper output, LogLevel dafnyLogLevel = LogLevel.Information) : base(output, dafnyLogLevel) { } -} \ No newline at end of file +} diff --git a/Source/DafnyLanguageServer/CounterExampleGeneration/DafnyModel.cs b/Source/DafnyLanguageServer/CounterExampleGeneration/DafnyModel.cs index 0cb7a6cb42..381eedd3aa 100644 --- a/Source/DafnyLanguageServer/CounterExampleGeneration/DafnyModel.cs +++ b/Source/DafnyLanguageServer/CounterExampleGeneration/DafnyModel.cs @@ -54,27 +54,27 @@ public DafnyModel(Model model, DafnyOptions options) { _ => 0 }; fSetSelect = ModelFuncWrapper.MergeFunctions(this, new List { "MapType0Select", "MapType1Select" }, 2); - fSeqLength = new ModelFuncWrapper(this, "Seq#Length", 1, tyArgMultiplier); - fSeqBuild = new ModelFuncWrapper(this, "Seq#Build", 2, tyArgMultiplier); - fSeqAppend = new ModelFuncWrapper(this, "Seq#Append", 2, tyArgMultiplier); - fSeqDrop = new ModelFuncWrapper(this, "Seq#Drop", 2, tyArgMultiplier); - fSeqTake = new ModelFuncWrapper(this, "Seq#Take", 2, tyArgMultiplier); - fSeqIndex = new ModelFuncWrapper(this, "Seq#Index", 2, tyArgMultiplier); - fSeqUpdate = new ModelFuncWrapper(this, "Seq#Update", 3, tyArgMultiplier); + fSeqLength = new ModelFuncWrapper(this, "Seq#Length", 1, 0); + fSeqBuild = new ModelFuncWrapper(this, "Seq#Build", 2, 0); + fSeqAppend = new ModelFuncWrapper(this, "Seq#Append", 2, 0); + fSeqDrop = new ModelFuncWrapper(this, "Seq#Drop", 2, 0); + fSeqTake = new ModelFuncWrapper(this, "Seq#Take", 2, 0); + fSeqIndex = new ModelFuncWrapper(this, "Seq#Index", 2, 0); + fSeqUpdate = new ModelFuncWrapper(this, "Seq#Update", 3, 0); fSeqCreate = new ModelFuncWrapper(this, "Seq#Create", 4, 0); - fSeqEmpty = new ModelFuncWrapper(this, "Seq#Empty", 1, 0); - fSetEmpty = new ModelFuncWrapper(this, "Set#Empty", 1, 0); - fSetUnion = new ModelFuncWrapper(this, "Set#Union", 2, tyArgMultiplier); - fSetUnionOne = new ModelFuncWrapper(this, "Set#UnionOne", 2, tyArgMultiplier); - fSetIntersection = new ModelFuncWrapper(this, "Set#Intersection", 2, tyArgMultiplier); - fSetDifference = new ModelFuncWrapper(this, "Set#Difference", 2, tyArgMultiplier); - fMapDomain = new ModelFuncWrapper(this, "Map#Domain", 1, 2 * tyArgMultiplier); - fMapElements = new ModelFuncWrapper(this, "Map#Elements", 1, 2 * tyArgMultiplier); - fMapBuild = new ModelFuncWrapper(this, "Map#Build", 3, 2 * tyArgMultiplier); + fSeqEmpty = new ModelFuncWrapper(this, "Seq#Empty", 0, 0); + fSetEmpty = new ModelFuncWrapper(this, "Set#Empty", 0, 0); + fSetUnion = new ModelFuncWrapper(this, "Set#Union", 2, 0); + fSetUnionOne = new ModelFuncWrapper(this, "Set#UnionOne", 2, 0); + fSetIntersection = new ModelFuncWrapper(this, "Set#Intersection", 2, 0); + fSetDifference = new ModelFuncWrapper(this, "Set#Difference", 2, 0); + fMapDomain = new ModelFuncWrapper(this, "Map#Domain", 1, 0); + fMapElements = new ModelFuncWrapper(this, "Map#Elements", 1, 0); + fMapBuild = new ModelFuncWrapper(this, "Map#Build", 3, 0); fIs = new ModelFuncWrapper(this, "$Is", 2, tyArgMultiplier); - fIsBox = new ModelFuncWrapper(this, "$IsBox", 2, tyArgMultiplier); + fIsBox = new ModelFuncWrapper(this, "$IsBox", 2, 0); fBox = new ModelFuncWrapper(this, "$Box", 1, tyArgMultiplier); - fDim = new ModelFuncWrapper(this, "FDim", 1, tyArgMultiplier); + fDim = new ModelFuncWrapper(this, "FDim", 1, 0); fIndexField = new ModelFuncWrapper(this, "IndexField", 1, 0); fMultiIndexField = new ModelFuncWrapper(this, "MultiIndexField", 2, 0); fDtype = new ModelFuncWrapper(this, "dtype", 1, 0); @@ -239,25 +239,9 @@ public static bool IsUserVariableName(string name) => /// /// Return the name of a 0-arity type function that maps to the element if such /// a function exists and is unique. Return null otherwise. - /// If the name is also aliased by a type parameter, return the name of the concrete type. /// private static string GetTrueTypeName(Model.Element element) { - string name = null; - if (element == null) { - return null; - } - foreach (var funcTuple in element.Names) { - if (funcTuple.Func.Arity != 0) { - continue; - } - // Special characters below appear in type parameters. This method returns the concrete type if possible - if ((name == null) || name.Contains("$") || name.StartsWith("#") || name.Contains("@")) { - name = funcTuple.Func.Name; - } else if (!funcTuple.Func.Name.Contains("$") && !funcTuple.Func.Name.StartsWith("#") && !funcTuple.Func.Name.Contains("@")) { - return null; - } - } - return name; + return element?.Names.FirstOrDefault(funcTuple => funcTuple.Func.Arity == 0)?.Func.Name; } /// Get the Dafny type of an element diff --git a/Source/DafnyPipeline.Test/expectedProverLog.smt2 b/Source/DafnyPipeline.Test/expectedProverLog.smt2 index da96d1c80f..98d5aff936 100644 --- a/Source/DafnyPipeline.Test/expectedProverLog.smt2 +++ b/Source/DafnyPipeline.Test/expectedProverLog.smt2 @@ -42,37 +42,37 @@ (declare-fun $generated@@15 (T@U) Int) (declare-fun $generated@@16 (Real) T@U) (declare-fun $generated@@17 (T@U) Real) -(declare-fun $generated@@24 (T@T T@U) Int) +(declare-fun $generated@@24 (T@U) Int) (declare-fun $generated@@25 (T@U) T@U) -(declare-fun $generated@@26 (T@T T@U) T@U) -(declare-fun $generated@@27 (T@U T@U) Bool) -(declare-fun $generated@@28 (T@T T@U) T@U) -(declare-fun $generated@@29 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@30 () T@T) -(declare-fun $generated@@31 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@32 () T@T) -(declare-fun $generated@@33 (T@T) T@T) -(declare-fun $generated@@34 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@35 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@36 (T@T) T@T) -(declare-fun $generated@@72 (T@T T@U T@U T@U) Bool) -(declare-fun $generated@@73 () T@U) -(declare-fun $generated@@74 () T@U) -(declare-fun $generated@@77 (T@T T@U T@U) Bool) -(declare-fun $generated@@78 (T@U) T@U) -(declare-fun $generated@@80 () T@U) -(declare-fun $generated@@83 () T@U) -(declare-fun $generated@@84 (T@T T@U T@U) T@U) -(declare-fun $generated@@85 (T@T T@U) Bool) -(declare-fun $generated@@86 (Int) Int) -(declare-fun $generated@@88 (T@T T@U) T@U) -(declare-fun $generated@@91 (T@U) Bool) -(declare-fun $generated@@103 (T@T T@U) T@U) -(declare-fun $generated@@109 (T@T T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@110 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@111 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@156 (T@T T@U) T@U) -(declare-fun $generated@@164 (T@U) T@U) +(declare-fun $generated@@26 (T@U) T@U) +(declare-fun $generated@@27 (T@T T@U T@U) Bool) +(declare-fun $generated@@28 () T@T) +(declare-fun $generated@@29 () T@U) +(declare-fun $generated@@30 () T@U) +(declare-fun $generated@@31 (T@U) T@U) +(declare-fun $generated@@33 (T@T T@U T@U T@U) Bool) +(declare-fun $generated@@34 () T@U) +(declare-fun $generated@@37 () T@U) +(declare-fun $generated@@38 (T@U T@U) T@U) +(declare-fun $generated@@39 (T@U) Bool) +(declare-fun $generated@@40 (T@T T@U) T@U) +(declare-fun $generated@@41 (T@T T@T T@U T@U) T@U) +(declare-fun $generated@@42 () T@T) +(declare-fun $generated@@43 () T@T) +(declare-fun $generated@@44 (T@T T@T) T@T) +(declare-fun $generated@@45 (T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@46 (T@T) T@T) +(declare-fun $generated@@47 (T@T) T@T) +(declare-fun $generated@@67 (T@U T@U) Bool) +(declare-fun $generated@@71 (Int) Int) +(declare-fun $generated@@73 (T@T T@U) T@U) +(declare-fun $generated@@76 (T@T T@U) T@U) +(declare-fun $generated@@79 (T@U) Bool) +(declare-fun $generated@@91 (T@U) T@U) +(declare-fun $generated@@98 (T@T T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@99 (T@U T@U T@U Bool) T@U) +(declare-fun $generated@@100 (T@T T@T T@T T@U T@U T@U T@U) T@U) +(declare-fun $generated@@136 (T@U) T@U) (assert (and (and (and (and (and (and (and (and (= ($generated@@8 $generated@@9) 0) (= ($generated@@8 $generated@@10) 1)) (= ($generated@@8 $generated@@11) 2)) (forall (($generated@@18 Bool) ) (! (= ($generated@@13 ($generated@@12 $generated@@18)) $generated@@18) :pattern ( ($generated@@12 $generated@@18)) ))) (forall (($generated@@19 T@U) ) (! (= ($generated@@12 ($generated@@13 $generated@@19)) $generated@@19) @@ -88,112 +88,110 @@ )))) (assert (distinct $generated $generated@@0 $generated@@1 $generated@@2 $generated@@3 $generated@@4 $generated@@5 $generated@@6 $generated@@7) ) -(assert (= ($generated@@24 $generated@@9 $generated@@1) 0)) +(assert (= ($generated@@24 $generated@@1) 0)) (assert (= ($generated@@25 $generated) $generated@@0)) -(assert (= ($generated@@26 $generated@@9 $generated@@1) $generated@@2)) -(assert (and (and (and (and (and (and (and (forall (($generated@@37 T@T) ($generated@@38 T@T) ($generated@@39 T@U) ($generated@@40 T@U) ($generated@@41 T@U) ) (! (= ($generated@@29 $generated@@37 $generated@@38 ($generated@@34 $generated@@37 $generated@@38 $generated@@40 $generated@@41 $generated@@39) $generated@@41) $generated@@39) - :weight 0 -)) (and (forall (($generated@@42 T@T) ($generated@@43 T@T) ($generated@@44 T@T) ($generated@@45 T@U) ($generated@@46 T@U) ($generated@@47 T@U) ($generated@@48 T@U) ) (! (or (= $generated@@43 $generated@@44) (= ($generated@@29 $generated@@44 $generated@@42 ($generated@@34 $generated@@43 $generated@@42 $generated@@46 $generated@@47 $generated@@45) $generated@@48) ($generated@@29 $generated@@44 $generated@@42 $generated@@46 $generated@@48))) +(assert (= ($generated@@26 $generated@@1) $generated@@2)) +(assert (= ($generated@@8 $generated@@28) 3)) +(assert (forall (($generated@@32 T@U) ) (! (= ($generated@@27 $generated@@28 $generated@@32 $generated@@29) (or (= $generated@@32 $generated@@30) (= ($generated@@31 $generated@@32) $generated@@29))) + :pattern ( ($generated@@27 $generated@@28 $generated@@32 $generated@@29)) +))) +(assert (forall (($generated@@35 T@U) ($generated@@36 T@U) ) (! (= ($generated@@33 $generated@@28 $generated@@35 $generated@@34 $generated@@36) ($generated@@33 $generated@@28 $generated@@35 $generated@@29 $generated@@36)) + :pattern ( ($generated@@33 $generated@@28 $generated@@35 $generated@@34 $generated@@36)) +))) +(assert (= ($generated@@24 $generated@@37) 0)) +(assert (= ($generated@@38 $generated@@4 $generated@@7) $generated@@37)) +(assert (not ($generated@@39 $generated@@37))) +(assert (and (and (and (and (and (and (forall (($generated@@48 T@T) ($generated@@49 T@T) ($generated@@50 T@U) ($generated@@51 T@U) ($generated@@52 T@U) ) (! (= ($generated@@41 $generated@@48 $generated@@49 ($generated@@45 $generated@@48 $generated@@49 $generated@@51 $generated@@52 $generated@@50) $generated@@52) $generated@@50) :weight 0 -)) (forall (($generated@@49 T@T) ($generated@@50 T@T) ($generated@@51 T@T) ($generated@@52 T@U) ($generated@@53 T@U) ($generated@@54 T@U) ($generated@@55 T@U) ) (! (or (= $generated@@54 $generated@@55) (= ($generated@@29 $generated@@51 $generated@@49 ($generated@@34 $generated@@50 $generated@@49 $generated@@53 $generated@@54 $generated@@52) $generated@@55) ($generated@@29 $generated@@51 $generated@@49 $generated@@53 $generated@@55))) +)) (forall (($generated@@53 T@T) ($generated@@54 T@T) ($generated@@55 T@U) ($generated@@56 T@U) ($generated@@57 T@U) ($generated@@58 T@U) ) (! (or (= $generated@@57 $generated@@58) (= ($generated@@41 $generated@@53 $generated@@54 ($generated@@45 $generated@@53 $generated@@54 $generated@@56 $generated@@57 $generated@@55) $generated@@58) ($generated@@41 $generated@@53 $generated@@54 $generated@@56 $generated@@58))) :weight 0 -)))) (= ($generated@@8 $generated@@30) 3)) (forall (($generated@@56 T@T) ($generated@@57 T@T) ($generated@@58 T@U) ($generated@@59 T@U) ($generated@@60 T@U) ) (! (= ($generated@@31 $generated@@56 $generated@@57 ($generated@@35 $generated@@56 $generated@@57 $generated@@59 $generated@@60 $generated@@58) $generated@@60) $generated@@58) - :weight 0 -))) (forall (($generated@@61 T@T) ($generated@@62 T@T) ($generated@@63 T@U) ($generated@@64 T@U) ($generated@@65 T@U) ($generated@@66 T@U) ) (! (or (= $generated@@65 $generated@@66) (= ($generated@@31 $generated@@61 $generated@@62 ($generated@@35 $generated@@61 $generated@@62 $generated@@64 $generated@@65 $generated@@63) $generated@@66) ($generated@@31 $generated@@61 $generated@@62 $generated@@64 $generated@@66))) - :weight 0 -))) (= ($generated@@8 $generated@@32) 4)) (forall (($generated@@67 T@T) ) (= ($generated@@8 ($generated@@33 $generated@@67)) 5))) (forall (($generated@@68 T@T) ) (! (= ($generated@@36 ($generated@@33 $generated@@68)) $generated@@68) - :pattern ( ($generated@@33 $generated@@68)) +))) (= ($generated@@8 $generated@@42) 4)) (= ($generated@@8 $generated@@43) 5)) (forall (($generated@@59 T@T) ($generated@@60 T@T) ) (= ($generated@@8 ($generated@@44 $generated@@59 $generated@@60)) 6))) (forall (($generated@@61 T@T) ($generated@@62 T@T) ) (! (= ($generated@@46 ($generated@@44 $generated@@61 $generated@@62)) $generated@@61) + :pattern ( ($generated@@44 $generated@@61 $generated@@62)) +))) (forall (($generated@@63 T@T) ($generated@@64 T@T) ) (! (= ($generated@@47 ($generated@@44 $generated@@63 $generated@@64)) $generated@@64) + :pattern ( ($generated@@44 $generated@@63 $generated@@64)) )))) -(assert (forall (($generated@@69 T@U) ($generated@@70 T@U) ) (! (=> ($generated@@27 $generated@@69 $generated@@70) (forall (($generated@@71 T@U) ) (! (=> ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@69 $generated@@71) $generated@@1))) ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@70 $generated@@71) $generated@@1)))) - :pattern ( ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@70 $generated@@71) $generated@@1))) +(assert (forall (($generated@@65 T@U) ($generated@@66 T@U) ) (! (= ($generated@@33 $generated@@28 $generated@@65 $generated@@29 $generated@@66) (or (= $generated@@65 $generated@@30) ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@66 $generated@@65) $generated@@1))))) + :pattern ( ($generated@@33 $generated@@28 $generated@@65 $generated@@29 $generated@@66)) ))) - :pattern ( ($generated@@27 $generated@@69 $generated@@70)) +(assert (forall (($generated@@68 T@U) ($generated@@69 T@U) ) (! (=> ($generated@@67 $generated@@68 $generated@@69) (forall (($generated@@70 T@U) ) (! (=> ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@68 $generated@@70) $generated@@1))) ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@69 $generated@@70) $generated@@1)))) + :pattern ( ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@69 $generated@@70) $generated@@1)) ))) -(assert (forall (($generated@@75 T@U) ($generated@@76 T@U) ) (! (= ($generated@@72 $generated@@32 $generated@@75 $generated@@73 $generated@@76) (or (= $generated@@75 $generated@@74) ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@76 $generated@@75) $generated@@1))))) - :pattern ( ($generated@@72 $generated@@32 $generated@@75 $generated@@73 $generated@@76)) + :pattern ( ($generated@@67 $generated@@68 $generated@@69)) ))) -(assert (forall (($generated@@79 T@U) ) (! (= ($generated@@77 $generated@@32 $generated@@79 $generated@@73) (or (= $generated@@79 $generated@@74) (= ($generated@@78 $generated@@79) $generated@@73))) - :pattern ( ($generated@@77 $generated@@32 $generated@@79 $generated@@73)) +(assert (forall (($generated@@72 Int) ) (! (= ($generated@@71 $generated@@72) $generated@@72) + :pattern ( ($generated@@71 $generated@@72)) ))) -(assert (forall (($generated@@81 T@U) ($generated@@82 T@U) ) (! (= ($generated@@72 $generated@@32 $generated@@81 $generated@@80 $generated@@82) ($generated@@72 $generated@@32 $generated@@81 $generated@@73 $generated@@82)) - :pattern ( ($generated@@72 $generated@@32 $generated@@81 $generated@@80 $generated@@82)) +(assert (forall (($generated@@74 T@U) ($generated@@75 T@T) ) (! (= ($generated@@73 $generated@@75 $generated@@74) $generated@@74) + :pattern ( ($generated@@73 $generated@@75 $generated@@74)) ))) -(assert (= ($generated@@24 $generated@@10 $generated@@83) 0)) -(assert (= ($generated@@84 $generated@@10 $generated@@4 $generated@@7) $generated@@83)) -(assert (not ($generated@@85 $generated@@10 $generated@@83))) -(assert (forall (($generated@@87 Int) ) (! (= ($generated@@86 $generated@@87) $generated@@87) - :pattern ( ($generated@@86 $generated@@87)) +(assert (forall (($generated@@77 T@U) ($generated@@78 T@T) ) (! (= ($generated@@76 $generated@@78 ($generated@@40 $generated@@78 $generated@@77)) $generated@@77) + :pattern ( ($generated@@40 $generated@@78 $generated@@77)) ))) -(assert (forall (($generated@@89 T@U) ($generated@@90 T@T) ) (! (= ($generated@@88 $generated@@90 $generated@@89) $generated@@89) - :pattern ( ($generated@@88 $generated@@90 $generated@@89)) +(assert ($generated@@39 $generated@@1)) +(assert (forall (($generated@@80 T@U) ($generated@@81 T@U) ) (! (=> (and (and ($generated@@79 $generated@@80) (and (or (not (= $generated@@81 $generated@@30)) (not true)) (= ($generated@@31 $generated@@81) $generated@@29))) ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@80 $generated@@81) $generated@@1)))) ($generated@@33 $generated@@10 ($generated@@40 $generated@@10 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@80 $generated@@81) $generated@@37)) $generated $generated@@80)) + :pattern ( ($generated@@40 $generated@@10 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@80 $generated@@81) $generated@@37))) ))) -(assert (forall (($generated@@92 T@U) ($generated@@93 T@U) ) (! (=> (and (and ($generated@@91 $generated@@92) (and (or (not (= $generated@@93 $generated@@74)) (not true)) (= ($generated@@78 $generated@@93) $generated@@73))) ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@92 $generated@@93) $generated@@1)))) ($generated@@72 $generated@@10 ($generated@@28 $generated@@10 ($generated@@29 $generated@@10 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@92 $generated@@93) $generated@@83)) $generated $generated@@92)) - :pattern ( ($generated@@28 $generated@@10 ($generated@@29 $generated@@10 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@92 $generated@@93) $generated@@83))) +(assert (forall (($generated@@82 T@U) ($generated@@83 T@U) ($generated@@84 T@U) ($generated@@85 T@U) ($generated@@86 T@T) ) (! (=> ($generated@@67 $generated@@82 $generated@@83) (=> ($generated@@33 $generated@@86 $generated@@84 $generated@@85 $generated@@82) ($generated@@33 $generated@@86 $generated@@84 $generated@@85 $generated@@83))) + :pattern ( ($generated@@67 $generated@@82 $generated@@83) ($generated@@33 $generated@@86 $generated@@84 $generated@@85 $generated@@82)) ))) -(assert ($generated@@85 $generated@@9 $generated@@1)) -(assert (forall (($generated@@94 T@U) ($generated@@95 T@U) ($generated@@96 T@U) ($generated@@97 T@U) ($generated@@98 T@T) ) (! (=> ($generated@@27 $generated@@94 $generated@@95) (=> ($generated@@72 $generated@@98 $generated@@96 $generated@@97 $generated@@94) ($generated@@72 $generated@@98 $generated@@96 $generated@@97 $generated@@95))) - :pattern ( ($generated@@27 $generated@@94 $generated@@95) ($generated@@72 $generated@@98 $generated@@96 $generated@@97 $generated@@94)) +(assert (forall (($generated@@87 T@U) ) (! (= ($generated@@27 $generated@@28 $generated@@87 $generated@@34) (and ($generated@@27 $generated@@28 $generated@@87 $generated@@29) (or (not (= $generated@@87 $generated@@30)) (not true)))) + :pattern ( ($generated@@27 $generated@@28 $generated@@87 $generated@@34)) ))) -(assert (forall (($generated@@99 T@U) ) (! (= ($generated@@77 $generated@@32 $generated@@99 $generated@@80) (and ($generated@@77 $generated@@32 $generated@@99 $generated@@73) (or (not (= $generated@@99 $generated@@74)) (not true)))) - :pattern ( ($generated@@77 $generated@@32 $generated@@99 $generated@@80)) +(assert (forall (($generated@@88 T@U) ($generated@@89 T@U) ($generated@@90 T@U) ) (! (=> (or (not (= $generated@@88 $generated@@90)) (not true)) (=> (and ($generated@@67 $generated@@88 $generated@@89) ($generated@@67 $generated@@89 $generated@@90)) ($generated@@67 $generated@@88 $generated@@90))) + :pattern ( ($generated@@67 $generated@@88 $generated@@89) ($generated@@67 $generated@@89 $generated@@90)) ))) -(assert (forall (($generated@@100 T@U) ($generated@@101 T@U) ($generated@@102 T@U) ) (! (=> (or (not (= $generated@@100 $generated@@102)) (not true)) (=> (and ($generated@@27 $generated@@100 $generated@@101) ($generated@@27 $generated@@101 $generated@@102)) ($generated@@27 $generated@@100 $generated@@102))) - :pattern ( ($generated@@27 $generated@@100 $generated@@101) ($generated@@27 $generated@@101 $generated@@102)) +(assert (forall (($generated@@92 T@U) ($generated@@93 T@U) ) (! (and (= ($generated@@91 ($generated@@38 $generated@@92 $generated@@93)) $generated@@92) (= ($generated@@26 ($generated@@38 $generated@@92 $generated@@93)) $generated@@93)) + :pattern ( ($generated@@38 $generated@@92 $generated@@93)) ))) -(assert (forall (($generated@@104 T@U) ($generated@@105 T@U) ($generated@@106 T@T) ) (! (and (= ($generated@@103 $generated@@106 ($generated@@84 $generated@@106 $generated@@104 $generated@@105)) $generated@@104) (= ($generated@@26 $generated@@106 ($generated@@84 $generated@@106 $generated@@104 $generated@@105)) $generated@@105)) - :pattern ( ($generated@@84 $generated@@106 $generated@@104 $generated@@105)) +(assert (forall (($generated@@94 T@U) ($generated@@95 T@T) ) (! (= ($generated@@40 $generated@@95 ($generated@@76 $generated@@95 $generated@@94)) $generated@@94) + :pattern ( ($generated@@76 $generated@@95 $generated@@94)) ))) -(assert (forall (($generated@@107 T@U) ($generated@@108 T@U) ) (! (=> (and ($generated@@91 $generated@@107) (and (or (not (= $generated@@108 $generated@@74)) (not true)) (= ($generated@@78 $generated@@108) $generated@@73))) ($generated@@77 $generated@@10 ($generated@@28 $generated@@10 ($generated@@29 $generated@@10 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@107 $generated@@108) $generated@@83)) $generated)) - :pattern ( ($generated@@28 $generated@@10 ($generated@@29 $generated@@10 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@107 $generated@@108) $generated@@83))) +(assert (forall (($generated@@96 T@U) ($generated@@97 T@U) ) (! (=> (and ($generated@@79 $generated@@96) (and (or (not (= $generated@@97 $generated@@30)) (not true)) (= ($generated@@31 $generated@@97) $generated@@29))) ($generated@@27 $generated@@10 ($generated@@40 $generated@@10 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@96 $generated@@97) $generated@@37)) $generated)) + :pattern ( ($generated@@40 $generated@@10 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@96 $generated@@97) $generated@@37))) ))) -(assert (and (forall (($generated@@112 T@T) ($generated@@113 T@T) ($generated@@114 T@T) ($generated@@115 T@U) ($generated@@116 T@U) ($generated@@117 T@U) ($generated@@118 T@U) ) (! (= ($generated@@109 $generated@@112 $generated@@113 $generated@@114 ($generated@@111 $generated@@112 $generated@@113 $generated@@114 $generated@@116 $generated@@117 $generated@@118 $generated@@115) $generated@@117 $generated@@118) $generated@@115) +(assert (and (forall (($generated@@101 T@T) ($generated@@102 T@T) ($generated@@103 T@T) ($generated@@104 T@U) ($generated@@105 T@U) ($generated@@106 T@U) ($generated@@107 T@U) ) (! (= ($generated@@98 $generated@@101 $generated@@102 $generated@@103 ($generated@@100 $generated@@101 $generated@@102 $generated@@103 $generated@@105 $generated@@106 $generated@@107 $generated@@104) $generated@@106 $generated@@107) $generated@@104) :weight 0 -)) (and (and (forall (($generated@@119 T@T) ($generated@@120 T@T) ($generated@@121 T@T) ($generated@@122 T@T) ($generated@@123 T@U) ($generated@@124 T@U) ($generated@@125 T@U) ($generated@@126 T@U) ($generated@@127 T@U) ($generated@@128 T@U) ) (! (or (= $generated@@121 $generated@@122) (= ($generated@@109 $generated@@122 $generated@@119 $generated@@120 ($generated@@111 $generated@@121 $generated@@119 $generated@@120 $generated@@124 $generated@@125 $generated@@126 $generated@@123) $generated@@127 $generated@@128) ($generated@@109 $generated@@122 $generated@@119 $generated@@120 $generated@@124 $generated@@127 $generated@@128))) +)) (and (forall (($generated@@108 T@T) ($generated@@109 T@T) ($generated@@110 T@T) ($generated@@111 T@U) ($generated@@112 T@U) ($generated@@113 T@U) ($generated@@114 T@U) ($generated@@115 T@U) ($generated@@116 T@U) ) (! (or (= $generated@@113 $generated@@115) (= ($generated@@98 $generated@@108 $generated@@109 $generated@@110 ($generated@@100 $generated@@108 $generated@@109 $generated@@110 $generated@@112 $generated@@113 $generated@@114 $generated@@111) $generated@@115 $generated@@116) ($generated@@98 $generated@@108 $generated@@109 $generated@@110 $generated@@112 $generated@@115 $generated@@116))) :weight 0 -)) (forall (($generated@@129 T@T) ($generated@@130 T@T) ($generated@@131 T@T) ($generated@@132 T@T) ($generated@@133 T@U) ($generated@@134 T@U) ($generated@@135 T@U) ($generated@@136 T@U) ($generated@@137 T@U) ($generated@@138 T@U) ) (! (or (= $generated@@135 $generated@@137) (= ($generated@@109 $generated@@132 $generated@@129 $generated@@130 ($generated@@111 $generated@@131 $generated@@129 $generated@@130 $generated@@134 $generated@@135 $generated@@136 $generated@@133) $generated@@137 $generated@@138) ($generated@@109 $generated@@132 $generated@@129 $generated@@130 $generated@@134 $generated@@137 $generated@@138))) - :weight 0 -))) (forall (($generated@@139 T@T) ($generated@@140 T@T) ($generated@@141 T@T) ($generated@@142 T@T) ($generated@@143 T@U) ($generated@@144 T@U) ($generated@@145 T@U) ($generated@@146 T@U) ($generated@@147 T@U) ($generated@@148 T@U) ) (! (or (= $generated@@146 $generated@@148) (= ($generated@@109 $generated@@142 $generated@@139 $generated@@140 ($generated@@111 $generated@@141 $generated@@139 $generated@@140 $generated@@144 $generated@@145 $generated@@146 $generated@@143) $generated@@147 $generated@@148) ($generated@@109 $generated@@142 $generated@@139 $generated@@140 $generated@@144 $generated@@147 $generated@@148))) +)) (forall (($generated@@117 T@T) ($generated@@118 T@T) ($generated@@119 T@T) ($generated@@120 T@U) ($generated@@121 T@U) ($generated@@122 T@U) ($generated@@123 T@U) ($generated@@124 T@U) ($generated@@125 T@U) ) (! (or (= $generated@@123 $generated@@125) (= ($generated@@98 $generated@@117 $generated@@118 $generated@@119 ($generated@@100 $generated@@117 $generated@@118 $generated@@119 $generated@@121 $generated@@122 $generated@@123 $generated@@120) $generated@@124 $generated@@125) ($generated@@98 $generated@@117 $generated@@118 $generated@@119 $generated@@121 $generated@@124 $generated@@125))) :weight 0 ))))) -(assert (forall (($generated@@149 T@U) ($generated@@150 T@U) ($generated@@151 T@U) ($generated@@152 Bool) ($generated@@153 T@U) ($generated@@154 T@U) ($generated@@155 T@T) ) (! (= ($generated@@13 ($generated@@109 $generated@@155 $generated@@32 $generated@@9 ($generated@@110 $generated@@149 $generated@@150 $generated@@151 $generated@@152) $generated@@153 $generated@@154)) (=> (and (or (not (= $generated@@153 $generated@@149)) (not true)) ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@150 $generated@@153) $generated@@151)))) $generated@@152)) - :pattern ( ($generated@@109 $generated@@155 $generated@@32 $generated@@9 ($generated@@110 $generated@@149 $generated@@150 $generated@@151 $generated@@152) $generated@@153 $generated@@154)) -))) -(assert (forall (($generated@@157 T@U) ($generated@@158 T@T) ) (! (= ($generated@@28 $generated@@158 ($generated@@156 $generated@@158 $generated@@157)) $generated@@157) - :pattern ( ($generated@@156 $generated@@158 $generated@@157)) +(assert (forall (($generated@@126 T@U) ($generated@@127 T@U) ($generated@@128 T@U) ($generated@@129 Bool) ($generated@@130 T@U) ($generated@@131 T@U) ) (! (= ($generated@@13 ($generated@@98 $generated@@28 $generated@@42 $generated@@9 ($generated@@99 $generated@@126 $generated@@127 $generated@@128 $generated@@129) $generated@@130 $generated@@131)) (=> (and (or (not (= $generated@@130 $generated@@126)) (not true)) ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@127 $generated@@130) $generated@@128)))) $generated@@129)) + :pattern ( ($generated@@98 $generated@@28 $generated@@42 $generated@@9 ($generated@@99 $generated@@126 $generated@@127 $generated@@128 $generated@@129) $generated@@130 $generated@@131)) ))) -(assert (forall (($generated@@159 T@U) ($generated@@160 T@U) ($generated@@161 T@U) ($generated@@162 T@U) ($generated@@163 T@T) ) (! (=> ($generated@@91 ($generated@@35 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160 ($generated@@34 $generated@@163 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160) $generated@@161 ($generated@@156 $generated@@163 $generated@@162)))) ($generated@@27 $generated@@159 ($generated@@35 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160 ($generated@@34 $generated@@163 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160) $generated@@161 ($generated@@156 $generated@@163 $generated@@162))))) - :pattern ( ($generated@@35 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160 ($generated@@34 $generated@@163 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@159 $generated@@160) $generated@@161 ($generated@@156 $generated@@163 $generated@@162)))) +(assert (forall (($generated@@132 T@U) ($generated@@133 T@U) ($generated@@134 T@U) ($generated@@135 T@U) ) (! (=> ($generated@@79 ($generated@@45 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133 ($generated@@45 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133) $generated@@134 $generated@@135))) ($generated@@67 $generated@@132 ($generated@@45 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133 ($generated@@45 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133) $generated@@134 $generated@@135)))) + :pattern ( ($generated@@45 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133 ($generated@@45 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@132 $generated@@133) $generated@@134 $generated@@135))) ))) -(assert (= ($generated@@25 $generated@@80) $generated@@3)) -(assert (= ($generated@@164 $generated@@80) $generated@@6)) -(assert (= ($generated@@25 $generated@@73) $generated@@5)) -(assert (= ($generated@@164 $generated@@73) $generated@@6)) -(assert (forall (($generated@@165 Int) ) (! (= ($generated@@156 $generated@@10 ($generated@@14 ($generated@@86 $generated@@165))) ($generated@@88 $generated@@30 ($generated@@156 $generated@@10 ($generated@@14 $generated@@165)))) - :pattern ( ($generated@@156 $generated@@10 ($generated@@14 ($generated@@86 $generated@@165)))) +(assert (= ($generated@@25 $generated@@34) $generated@@3)) +(assert (= ($generated@@136 $generated@@34) $generated@@6)) +(assert (= ($generated@@25 $generated@@29) $generated@@5)) +(assert (= ($generated@@136 $generated@@29) $generated@@6)) +(assert (forall (($generated@@137 Int) ) (! (= ($generated@@76 $generated@@10 ($generated@@14 ($generated@@71 $generated@@137))) ($generated@@73 $generated@@43 ($generated@@76 $generated@@10 ($generated@@14 $generated@@137)))) + :pattern ( ($generated@@76 $generated@@10 ($generated@@14 ($generated@@71 $generated@@137)))) ))) -(assert (forall (($generated@@166 T@U) ($generated@@167 T@T) ) (! (= ($generated@@156 $generated@@167 ($generated@@88 $generated@@167 $generated@@166)) ($generated@@88 $generated@@30 ($generated@@156 $generated@@167 $generated@@166))) - :pattern ( ($generated@@156 $generated@@167 ($generated@@88 $generated@@167 $generated@@166))) +(assert (forall (($generated@@138 T@U) ($generated@@139 T@T) ) (! (= ($generated@@76 $generated@@139 ($generated@@73 $generated@@139 $generated@@138)) ($generated@@73 $generated@@43 ($generated@@76 $generated@@139 $generated@@138))) + :pattern ( ($generated@@76 $generated@@139 ($generated@@73 $generated@@139 $generated@@138))) ))) -(assert (forall (($generated@@168 T@U) ($generated@@169 T@U) ) (! ($generated@@72 $generated@@10 $generated@@169 $generated $generated@@168) - :pattern ( ($generated@@72 $generated@@10 $generated@@169 $generated $generated@@168)) +(assert (forall (($generated@@140 T@U) ($generated@@141 T@U) ) (! ($generated@@33 $generated@@10 $generated@@141 $generated $generated@@140) + :pattern ( ($generated@@33 $generated@@10 $generated@@141 $generated $generated@@140)) ))) -(assert (forall (($generated@@170 T@U) ) (! ($generated@@77 $generated@@10 $generated@@170 $generated) - :pattern ( ($generated@@77 $generated@@10 $generated@@170 $generated)) +(assert (forall (($generated@@142 T@U) ) (! ($generated@@27 $generated@@10 $generated@@142 $generated) + :pattern ( ($generated@@27 $generated@@10 $generated@@142 $generated)) ))) (push 1) (declare-fun ControlFlow (Int Int) Int) -(declare-fun $generated@@171 () T@U) -(declare-fun $generated@@172 () T@U) -(declare-fun $generated@@173 () Bool) -(declare-fun $generated@@174 () T@U) -(declare-fun $generated@@175 () T@U) -(declare-fun $generated@@176 () T@U) -(declare-fun $generated@@177 (T@U) Bool) -(declare-fun $generated@@178 () T@U) -(declare-fun $generated@@179 () Int) -(declare-fun $generated@@180 () T@U) -(declare-fun $generated@@181 () T@U) -(declare-fun $generated@@182 () Int) +(declare-fun $generated@@143 () T@U) +(declare-fun $generated@@144 () T@U) +(declare-fun $generated@@145 () Bool) +(declare-fun $generated@@146 () T@U) +(declare-fun $generated@@147 () T@U) +(declare-fun $generated@@148 () T@U) +(declare-fun $generated@@149 (T@U) Bool) +(declare-fun $generated@@150 () T@U) +(declare-fun $generated@@151 () Int) +(declare-fun $generated@@152 () T@U) +(declare-fun $generated@@153 () T@U) +(declare-fun $generated@@154 () Int) (set-option :timeout 0) (set-option :rlimit 0) (set-option :auto_config false) @@ -209,11 +207,11 @@ (set-option :pp.bv_literals false) (set-option :smt.arith.solver 2) (assert (not - (=> (= (ControlFlow 0 0) 6) (let (($generated@@183 (=> (and (= $generated@@171 ($generated@@110 $generated@@74 $generated@@172 $generated@@1 false)) (=> $generated@@173 (and ($generated@@77 $generated@@32 $generated@@174 $generated@@80) ($generated@@72 $generated@@32 $generated@@174 $generated@@80 $generated@@172)))) (=> (and (and (or (not (= $generated@@175 $generated@@74)) (not true)) (and ($generated@@77 $generated@@32 $generated@@175 $generated@@80) ($generated@@72 $generated@@32 $generated@@175 $generated@@80 $generated@@172))) (and ($generated@@91 $generated@@176) ($generated@@177 $generated@@176))) (=> (and (and (and (or (not (= $generated@@178 $generated@@74)) (not true)) (and ($generated@@77 $generated@@32 $generated@@178 $generated@@80) ($generated@@72 $generated@@32 $generated@@178 $generated@@80 $generated@@176))) (not ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@172 $generated@@178) $generated@@1))))) (and (forall (($generated@@184 T@U) ) (! (=> (and (or (not (= $generated@@184 $generated@@74)) (not true)) ($generated@@13 ($generated@@28 $generated@@9 ($generated@@29 $generated@@9 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@172 $generated@@184) $generated@@1)))) (= ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@176 $generated@@184) ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@172 $generated@@184))) - :pattern ( ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@176 $generated@@184)) -)) ($generated@@27 $generated@@172 $generated@@176))) (and (=> (= (ControlFlow 0 2) (- 0 5)) true) (and (=> (= (ControlFlow 0 2) (- 0 4)) (or (not (= $generated@@178 $generated@@74)) (not true))) (=> (or (not (= $generated@@178 $generated@@74)) (not true)) (and (=> (= (ControlFlow 0 2) (- 0 3)) ($generated@@13 ($generated@@109 $generated@@10 $generated@@32 $generated@@9 $generated@@171 $generated@@178 $generated@@83))) (=> ($generated@@13 ($generated@@109 $generated@@10 $generated@@32 $generated@@9 $generated@@171 $generated@@178 $generated@@83)) (=> (and (and (= $generated@@179 ($generated@@86 4)) (= $generated@@180 ($generated@@35 $generated@@32 ($generated@@33 $generated@@30) $generated@@176 $generated@@178 ($generated@@34 $generated@@10 $generated@@30 ($generated@@31 $generated@@32 ($generated@@33 $generated@@30) $generated@@176 $generated@@178) $generated@@83 ($generated@@156 $generated@@10 ($generated@@14 $generated@@179)))))) (and ($generated@@91 $generated@@180) (= (ControlFlow 0 2) (- 0 1)))) ($generated@@13 ($generated@@88 $generated@@9 ($generated@@12 false)))))))))))))) -(let (($generated@@185 (=> (and ($generated@@91 $generated@@172) ($generated@@177 $generated@@172)) (=> (and (and (=> $generated@@173 (and ($generated@@77 $generated@@32 $generated@@181 $generated@@80) ($generated@@72 $generated@@32 $generated@@181 $generated@@80 $generated@@172))) true) (and (= 0 $generated@@182) (= (ControlFlow 0 6) 2))) $generated@@183)))) -$generated@@185))) + (=> (= (ControlFlow 0 0) 6) (let (($generated@@155 (=> (and (= $generated@@143 ($generated@@99 $generated@@30 $generated@@144 $generated@@1 false)) (=> $generated@@145 (and ($generated@@27 $generated@@28 $generated@@146 $generated@@34) ($generated@@33 $generated@@28 $generated@@146 $generated@@34 $generated@@144)))) (=> (and (and (or (not (= $generated@@147 $generated@@30)) (not true)) (and ($generated@@27 $generated@@28 $generated@@147 $generated@@34) ($generated@@33 $generated@@28 $generated@@147 $generated@@34 $generated@@144))) (and ($generated@@79 $generated@@148) ($generated@@149 $generated@@148))) (=> (and (and (and (or (not (= $generated@@150 $generated@@30)) (not true)) (and ($generated@@27 $generated@@28 $generated@@150 $generated@@34) ($generated@@33 $generated@@28 $generated@@150 $generated@@34 $generated@@148))) (not ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@144 $generated@@150) $generated@@1))))) (and (forall (($generated@@156 T@U) ) (! (=> (and (or (not (= $generated@@156 $generated@@30)) (not true)) ($generated@@13 ($generated@@40 $generated@@9 ($generated@@41 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@144 $generated@@156) $generated@@1)))) (= ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@148 $generated@@156) ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@144 $generated@@156))) + :pattern ( ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@148 $generated@@156)) +)) ($generated@@67 $generated@@144 $generated@@148))) (and (=> (= (ControlFlow 0 2) (- 0 5)) true) (and (=> (= (ControlFlow 0 2) (- 0 4)) (or (not (= $generated@@150 $generated@@30)) (not true))) (=> (or (not (= $generated@@150 $generated@@30)) (not true)) (and (=> (= (ControlFlow 0 2) (- 0 3)) ($generated@@13 ($generated@@98 $generated@@28 $generated@@42 $generated@@9 $generated@@143 $generated@@150 $generated@@37))) (=> ($generated@@13 ($generated@@98 $generated@@28 $generated@@42 $generated@@9 $generated@@143 $generated@@150 $generated@@37)) (=> (and (and (= $generated@@151 ($generated@@71 4)) (= $generated@@152 ($generated@@45 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@148 $generated@@150 ($generated@@45 $generated@@42 $generated@@43 ($generated@@41 $generated@@28 ($generated@@44 $generated@@42 $generated@@43) $generated@@148 $generated@@150) $generated@@37 ($generated@@76 $generated@@10 ($generated@@14 $generated@@151)))))) (and ($generated@@79 $generated@@152) (= (ControlFlow 0 2) (- 0 1)))) ($generated@@13 ($generated@@73 $generated@@9 ($generated@@12 false)))))))))))))) +(let (($generated@@157 (=> (and ($generated@@79 $generated@@144) ($generated@@149 $generated@@144)) (=> (and (and (=> $generated@@145 (and ($generated@@27 $generated@@28 $generated@@153 $generated@@34) ($generated@@33 $generated@@28 $generated@@153 $generated@@34 $generated@@144))) true) (and (= 0 $generated@@154) (= (ControlFlow 0 6) 2))) $generated@@155)))) +$generated@@157))) )) (check-sat) (get-info :reason-unknown) @@ -278,47 +276,47 @@ $generated@@185))) (declare-fun $generated@@22 (T@U) Int) (declare-fun $generated@@23 (Real) T@U) (declare-fun $generated@@24 (T@U) Real) -(declare-fun $generated@@31 (T@T T@U) Int) +(declare-fun $generated@@31 (T@U) Int) (declare-fun $generated@@32 (T@U) T@U) -(declare-fun $generated@@33 (T@T T@U) T@U) +(declare-fun $generated@@33 (T@U) T@U) (declare-fun $generated@@34 (T@T T@U T@U T@U) Bool) (declare-fun $generated@@35 () T@U) -(declare-fun $generated@@38 () T@T) -(declare-fun $generated@@39 () T@U) +(declare-fun $generated@@38 (T@T T@U T@U) Bool) +(declare-fun $generated@@39 () T@T) (declare-fun $generated@@40 () T@U) -(declare-fun $generated@@41 (T@T T@U) T@U) -(declare-fun $generated@@42 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@43 () T@T) -(declare-fun $generated@@44 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@45 (T@T) T@T) -(declare-fun $generated@@46 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@47 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@48 (T@T) T@T) -(declare-fun $generated@@83 () T@U) -(declare-fun $generated@@86 (T@T T@U T@U) Bool) -(declare-fun $generated@@87 (T@U) T@U) -(declare-fun $generated@@90 () T@U) -(declare-fun $generated@@93 () T@U) -(declare-fun $generated@@96 () T@U) -(declare-fun $generated@@97 (T@T T@U T@U) T@U) -(declare-fun $generated@@98 (T@T T@U) Bool) -(declare-fun $generated@@99 () T@U) -(declare-fun $generated@@100 () Int) -(declare-fun $generated@@101 (T@U Int T@U) Int) -(declare-fun $generated@@102 (T@U Int T@U) Bool) -(declare-fun $generated@@103 (T@U) Bool) -(declare-fun $generated@@104 (Int) Int) -(declare-fun $generated@@109 (T@T T@U) T@U) -(declare-fun $generated@@119 (T@T T@U T@U) Bool) -(declare-fun $generated@@129 (T@T T@U T@U) T@U) -(declare-fun $generated@@138 (T@T T@U) T@U) -(declare-fun $generated@@147 (T@T T@U) T@U) -(declare-fun $generated@@150 (T@T) T@U) -(declare-fun $generated@@153 (T@T T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@154 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@155 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@201 (T@T T@U T@U) Bool) -(declare-fun $generated@@206 (T@U) T@U) +(declare-fun $generated@@41 () T@U) +(declare-fun $generated@@42 (T@U) T@U) +(declare-fun $generated@@44 () T@U) +(declare-fun $generated@@46 () T@U) +(declare-fun $generated@@49 () T@U) +(declare-fun $generated@@52 () T@U) +(declare-fun $generated@@53 (T@U T@U) T@U) +(declare-fun $generated@@54 (T@U) Bool) +(declare-fun $generated@@55 () T@U) +(declare-fun $generated@@56 (T@T T@U) T@U) +(declare-fun $generated@@57 (T@T T@T T@U T@U) T@U) +(declare-fun $generated@@58 () T@T) +(declare-fun $generated@@59 () T@T) +(declare-fun $generated@@60 (T@T T@T) T@T) +(declare-fun $generated@@61 (T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@62 (T@T) T@T) +(declare-fun $generated@@63 (T@T) T@T) +(declare-fun $generated@@85 (Int) Int) +(declare-fun $generated@@87 (T@T T@U) T@U) +(declare-fun $generated@@90 (T@T T@U) T@U) +(declare-fun $generated@@93 () Int) +(declare-fun $generated@@94 (T@U Int T@U) Int) +(declare-fun $generated@@95 (T@U Int T@U) Bool) +(declare-fun $generated@@96 (T@U) Bool) +(declare-fun $generated@@103 (T@U T@U) Bool) +(declare-fun $generated@@115 (T@U T@U) T@U) +(declare-fun $generated@@122 (T@U) T@U) +(declare-fun $generated@@131 () T@U) +(declare-fun $generated@@133 (T@U T@U) Bool) +(declare-fun $generated@@137 (T@U) T@U) +(declare-fun $generated@@138 (T@T T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@139 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@140 (T@T T@T T@T T@U T@U T@U T@U) T@U) (assert (and (and (and (and (and (and (and (and (= ($generated@@15 $generated@@16) 0) (= ($generated@@15 $generated@@17) 1)) (= ($generated@@15 $generated@@18) 2)) (forall (($generated@@25 Bool) ) (! (= ($generated@@20 ($generated@@19 $generated@@25)) $generated@@25) :pattern ( ($generated@@19 $generated@@25)) ))) (forall (($generated@@26 T@U) ) (! (= ($generated@@19 ($generated@@20 $generated@@26)) $generated@@26) @@ -334,158 +332,156 @@ $generated@@185))) )))) (assert (distinct $generated $generated@@0 $generated@@1 $generated@@2 $generated@@3 $generated@@4 $generated@@5 $generated@@6 $generated@@7 $generated@@8 $generated@@9 $generated@@10 $generated@@11 $generated@@12 $generated@@13 $generated@@14) ) -(assert (= ($generated@@31 $generated@@16 $generated@@1) 0)) +(assert (= ($generated@@31 $generated@@1) 0)) (assert (= ($generated@@32 $generated) $generated@@0)) -(assert (= ($generated@@33 $generated@@16 $generated@@1) $generated@@2)) +(assert (= ($generated@@33 $generated@@1) $generated@@2)) (assert (forall (($generated@@36 T@U) ($generated@@37 T@U) ) (! ($generated@@34 $generated@@17 $generated@@36 $generated@@35 $generated@@37) :pattern ( ($generated@@34 $generated@@17 $generated@@36 $generated@@35 $generated@@37)) ))) -(assert (and (and (and (and (and (and (and (= ($generated@@15 $generated@@38) 3) (forall (($generated@@49 T@T) ($generated@@50 T@T) ($generated@@51 T@U) ($generated@@52 T@U) ($generated@@53 T@U) ) (! (= ($generated@@42 $generated@@49 $generated@@50 ($generated@@46 $generated@@49 $generated@@50 $generated@@52 $generated@@53 $generated@@51) $generated@@53) $generated@@51) - :weight 0 -))) (and (forall (($generated@@54 T@T) ($generated@@55 T@T) ($generated@@56 T@T) ($generated@@57 T@U) ($generated@@58 T@U) ($generated@@59 T@U) ($generated@@60 T@U) ) (! (or (= $generated@@55 $generated@@56) (= ($generated@@42 $generated@@56 $generated@@54 ($generated@@46 $generated@@55 $generated@@54 $generated@@58 $generated@@59 $generated@@57) $generated@@60) ($generated@@42 $generated@@56 $generated@@54 $generated@@58 $generated@@60))) - :weight 0 -)) (forall (($generated@@61 T@T) ($generated@@62 T@T) ($generated@@63 T@T) ($generated@@64 T@U) ($generated@@65 T@U) ($generated@@66 T@U) ($generated@@67 T@U) ) (! (or (= $generated@@66 $generated@@67) (= ($generated@@42 $generated@@63 $generated@@61 ($generated@@46 $generated@@62 $generated@@61 $generated@@65 $generated@@66 $generated@@64) $generated@@67) ($generated@@42 $generated@@63 $generated@@61 $generated@@65 $generated@@67))) - :weight 0 -)))) (= ($generated@@15 $generated@@43) 4)) (forall (($generated@@68 T@T) ($generated@@69 T@T) ($generated@@70 T@U) ($generated@@71 T@U) ($generated@@72 T@U) ) (! (= ($generated@@44 $generated@@68 $generated@@69 ($generated@@47 $generated@@68 $generated@@69 $generated@@71 $generated@@72 $generated@@70) $generated@@72) $generated@@70) +(assert (= ($generated@@15 $generated@@39) 3)) +(assert (forall (($generated@@43 T@U) ) (! (= ($generated@@38 $generated@@39 $generated@@43 $generated@@40) (or (= $generated@@43 $generated@@41) (= ($generated@@42 $generated@@43) $generated@@40))) + :pattern ( ($generated@@38 $generated@@39 $generated@@43 $generated@@40)) +))) +(assert (forall (($generated@@45 T@U) ) (! (= ($generated@@38 $generated@@39 $generated@@45 $generated@@44) (or (= $generated@@45 $generated@@41) (= ($generated@@42 $generated@@45) $generated@@44))) + :pattern ( ($generated@@38 $generated@@39 $generated@@45 $generated@@44)) +))) +(assert (forall (($generated@@47 T@U) ($generated@@48 T@U) ) (! (= ($generated@@34 $generated@@39 $generated@@47 $generated@@46 $generated@@48) ($generated@@34 $generated@@39 $generated@@47 $generated@@40 $generated@@48)) + :pattern ( ($generated@@34 $generated@@39 $generated@@47 $generated@@46 $generated@@48)) +))) +(assert (forall (($generated@@50 T@U) ($generated@@51 T@U) ) (! (= ($generated@@34 $generated@@39 $generated@@50 $generated@@49 $generated@@51) ($generated@@34 $generated@@39 $generated@@50 $generated@@44 $generated@@51)) + :pattern ( ($generated@@34 $generated@@39 $generated@@50 $generated@@49 $generated@@51)) +))) +(assert (= ($generated@@31 $generated@@52) 0)) +(assert (= ($generated@@53 $generated@@5 $generated@@13) $generated@@52)) +(assert (not ($generated@@54 $generated@@52))) +(assert (= ($generated@@31 $generated@@55) 0)) +(assert (= ($generated@@53 $generated@@8 $generated@@14) $generated@@55)) +(assert (not ($generated@@54 $generated@@55))) +(assert (and (and (and (and (and (and (forall (($generated@@64 T@T) ($generated@@65 T@T) ($generated@@66 T@U) ($generated@@67 T@U) ($generated@@68 T@U) ) (! (= ($generated@@57 $generated@@64 $generated@@65 ($generated@@61 $generated@@64 $generated@@65 $generated@@67 $generated@@68 $generated@@66) $generated@@68) $generated@@66) :weight 0 -))) (forall (($generated@@73 T@T) ($generated@@74 T@T) ($generated@@75 T@U) ($generated@@76 T@U) ($generated@@77 T@U) ($generated@@78 T@U) ) (! (or (= $generated@@77 $generated@@78) (= ($generated@@44 $generated@@73 $generated@@74 ($generated@@47 $generated@@73 $generated@@74 $generated@@76 $generated@@77 $generated@@75) $generated@@78) ($generated@@44 $generated@@73 $generated@@74 $generated@@76 $generated@@78))) +)) (forall (($generated@@69 T@T) ($generated@@70 T@T) ($generated@@71 T@U) ($generated@@72 T@U) ($generated@@73 T@U) ($generated@@74 T@U) ) (! (or (= $generated@@73 $generated@@74) (= ($generated@@57 $generated@@69 $generated@@70 ($generated@@61 $generated@@69 $generated@@70 $generated@@72 $generated@@73 $generated@@71) $generated@@74) ($generated@@57 $generated@@69 $generated@@70 $generated@@72 $generated@@74))) :weight 0 -))) (forall (($generated@@79 T@T) ) (= ($generated@@15 ($generated@@45 $generated@@79)) 5))) (forall (($generated@@80 T@T) ) (! (= ($generated@@48 ($generated@@45 $generated@@80)) $generated@@80) - :pattern ( ($generated@@45 $generated@@80)) +))) (= ($generated@@15 $generated@@58) 4)) (= ($generated@@15 $generated@@59) 5)) (forall (($generated@@75 T@T) ($generated@@76 T@T) ) (= ($generated@@15 ($generated@@60 $generated@@75 $generated@@76)) 6))) (forall (($generated@@77 T@T) ($generated@@78 T@T) ) (! (= ($generated@@62 ($generated@@60 $generated@@77 $generated@@78)) $generated@@77) + :pattern ( ($generated@@60 $generated@@77 $generated@@78)) +))) (forall (($generated@@79 T@T) ($generated@@80 T@T) ) (! (= ($generated@@63 ($generated@@60 $generated@@79 $generated@@80)) $generated@@80) + :pattern ( ($generated@@60 $generated@@79 $generated@@80)) )))) -(assert (forall (($generated@@81 T@U) ($generated@@82 T@U) ) (! (= ($generated@@34 $generated@@38 $generated@@81 $generated@@39 $generated@@82) (or (= $generated@@81 $generated@@40) ($generated@@20 ($generated@@41 $generated@@16 ($generated@@42 $generated@@16 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@82 $generated@@81) $generated@@1))))) - :pattern ( ($generated@@34 $generated@@38 $generated@@81 $generated@@39 $generated@@82)) -))) -(assert (forall (($generated@@84 T@U) ($generated@@85 T@U) ) (! (= ($generated@@34 $generated@@38 $generated@@84 $generated@@83 $generated@@85) (or (= $generated@@84 $generated@@40) ($generated@@20 ($generated@@41 $generated@@16 ($generated@@42 $generated@@16 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@85 $generated@@84) $generated@@1))))) - :pattern ( ($generated@@34 $generated@@38 $generated@@84 $generated@@83 $generated@@85)) +(assert (forall (($generated@@81 T@U) ($generated@@82 T@U) ) (! (= ($generated@@34 $generated@@39 $generated@@81 $generated@@40 $generated@@82) (or (= $generated@@81 $generated@@41) ($generated@@20 ($generated@@56 $generated@@16 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@82 $generated@@81) $generated@@1))))) + :pattern ( ($generated@@34 $generated@@39 $generated@@81 $generated@@40 $generated@@82)) ))) -(assert (forall (($generated@@88 T@U) ) (! (= ($generated@@86 $generated@@38 $generated@@88 $generated@@39) (or (= $generated@@88 $generated@@40) (= ($generated@@87 $generated@@88) $generated@@39))) - :pattern ( ($generated@@86 $generated@@38 $generated@@88 $generated@@39)) +(assert (forall (($generated@@83 T@U) ($generated@@84 T@U) ) (! (= ($generated@@34 $generated@@39 $generated@@83 $generated@@44 $generated@@84) (or (= $generated@@83 $generated@@41) ($generated@@20 ($generated@@56 $generated@@16 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@84 $generated@@83) $generated@@1))))) + :pattern ( ($generated@@34 $generated@@39 $generated@@83 $generated@@44 $generated@@84)) ))) -(assert (forall (($generated@@89 T@U) ) (! (= ($generated@@86 $generated@@38 $generated@@89 $generated@@83) (or (= $generated@@89 $generated@@40) (= ($generated@@87 $generated@@89) $generated@@83))) - :pattern ( ($generated@@86 $generated@@38 $generated@@89 $generated@@83)) +(assert (forall (($generated@@86 Int) ) (! (= ($generated@@85 $generated@@86) $generated@@86) + :pattern ( ($generated@@85 $generated@@86)) ))) -(assert (forall (($generated@@91 T@U) ($generated@@92 T@U) ) (! (= ($generated@@34 $generated@@38 $generated@@91 $generated@@90 $generated@@92) ($generated@@34 $generated@@38 $generated@@91 $generated@@39 $generated@@92)) - :pattern ( ($generated@@34 $generated@@38 $generated@@91 $generated@@90 $generated@@92)) +(assert (forall (($generated@@88 T@U) ($generated@@89 T@T) ) (! (= ($generated@@87 $generated@@89 $generated@@88) $generated@@88) + :pattern ( ($generated@@87 $generated@@89 $generated@@88)) ))) -(assert (forall (($generated@@94 T@U) ($generated@@95 T@U) ) (! (= ($generated@@34 $generated@@38 $generated@@94 $generated@@93 $generated@@95) ($generated@@34 $generated@@38 $generated@@94 $generated@@83 $generated@@95)) - :pattern ( ($generated@@34 $generated@@38 $generated@@94 $generated@@93 $generated@@95)) +(assert (forall (($generated@@91 T@U) ($generated@@92 T@T) ) (! (= ($generated@@90 $generated@@92 ($generated@@56 $generated@@92 $generated@@91)) $generated@@91) + :pattern ( ($generated@@56 $generated@@92 $generated@@91)) ))) -(assert (= ($generated@@31 $generated@@38 $generated@@96) 0)) -(assert (= ($generated@@97 $generated@@38 $generated@@5 $generated@@13) $generated@@96)) -(assert (not ($generated@@98 $generated@@38 $generated@@96))) -(assert (= ($generated@@31 $generated@@17 $generated@@99) 0)) -(assert (= ($generated@@97 $generated@@17 $generated@@8 $generated@@14) $generated@@99)) -(assert (not ($generated@@98 $generated@@17 $generated@@99))) -(assert (=> (<= 1 $generated@@100) (forall (($generated@@105 T@U) ($generated@@106 Int) ($generated@@107 T@U) ) (! (=> (or ($generated@@102 $generated@@105 $generated@@106 $generated@@107) (and (< 1 $generated@@100) (and ($generated@@103 $generated@@105) ($generated@@86 $generated@@38 $generated@@107 $generated@@90)))) (and (= ($generated@@101 $generated@@105 $generated@@106 $generated@@107) ($generated@@22 ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@105 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@105 $generated@@107) $generated@@96))) $generated@@99)))) (<= ($generated@@104 0) ($generated@@101 $generated@@105 $generated@@106 $generated@@107)))) - :pattern ( ($generated@@101 $generated@@105 $generated@@106 $generated@@107)) +(assert (=> (<= 1 $generated@@93) (forall (($generated@@97 T@U) ($generated@@98 Int) ($generated@@99 T@U) ) (! (=> (or ($generated@@95 $generated@@97 $generated@@98 $generated@@99) (and (< 1 $generated@@93) (and ($generated@@96 $generated@@97) ($generated@@38 $generated@@39 $generated@@99 $generated@@46)))) (and (= ($generated@@94 $generated@@97 $generated@@98 $generated@@99) ($generated@@22 ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@97 ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@97 $generated@@99) $generated@@52))) $generated@@55)))) (<= ($generated@@85 0) ($generated@@94 $generated@@97 $generated@@98 $generated@@99)))) + :pattern ( ($generated@@94 $generated@@97 $generated@@98 $generated@@99)) )))) -(assert (forall (($generated@@108 Int) ) (! (= ($generated@@104 $generated@@108) $generated@@108) - :pattern ( ($generated@@104 $generated@@108)) +(assert (forall (($generated@@100 T@U) ) (! (= ($generated@@38 $generated@@17 $generated@@100 $generated@@35) (<= ($generated@@85 0) ($generated@@22 $generated@@100))) + :pattern ( ($generated@@38 $generated@@17 $generated@@100 $generated@@35)) ))) -(assert (forall (($generated@@110 T@U) ($generated@@111 T@T) ) (! (= ($generated@@109 $generated@@111 $generated@@110) $generated@@110) - :pattern ( ($generated@@109 $generated@@111 $generated@@110)) +(assert ($generated@@54 $generated@@1)) +(assert (forall (($generated@@101 T@U) ($generated@@102 T@U) ) (! (=> (and (and ($generated@@96 $generated@@101) (and (or (not (= $generated@@102 $generated@@41)) (not true)) (= ($generated@@42 $generated@@102) $generated@@44))) ($generated@@20 ($generated@@56 $generated@@16 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@101 $generated@@102) $generated@@1)))) ($generated@@34 $generated@@17 ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@101 $generated@@102) $generated@@55)) $generated $generated@@101)) + :pattern ( ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@101 $generated@@102) $generated@@55))) ))) -(assert (forall (($generated@@112 T@U) ($generated@@113 T@U) ) (! (=> (and (and ($generated@@103 $generated@@112) (and (or (not (= $generated@@113 $generated@@40)) (not true)) (= ($generated@@87 $generated@@113) $generated@@83))) ($generated@@20 ($generated@@41 $generated@@16 ($generated@@42 $generated@@16 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@112 $generated@@113) $generated@@1)))) ($generated@@34 $generated@@17 ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@112 $generated@@113) $generated@@99)) $generated $generated@@112)) - :pattern ( ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@112 $generated@@113) $generated@@99))) +(assert (forall (($generated@@104 T@U) ($generated@@105 T@U) ) (! (= ($generated@@103 $generated@@104 $generated@@105) (forall (($generated@@106 T@U) ) (! (= ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@104 $generated@@106)) ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@105 $generated@@106))) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 $generated@@104 $generated@@106)) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 $generated@@105 $generated@@106)) ))) -(assert (forall (($generated@@114 T@U) ) (! (= ($generated@@86 $generated@@17 $generated@@114 $generated@@35) (<= ($generated@@104 0) ($generated@@22 $generated@@114))) - :pattern ( ($generated@@86 $generated@@17 $generated@@114 $generated@@35)) + :pattern ( ($generated@@103 $generated@@104 $generated@@105)) ))) -(assert (forall (($generated@@115 T@U) ($generated@@116 T@U) ) (! (=> (and (and ($generated@@103 $generated@@115) (and (or (not (= $generated@@116 $generated@@40)) (not true)) (= ($generated@@87 $generated@@116) $generated@@39))) ($generated@@20 ($generated@@41 $generated@@16 ($generated@@42 $generated@@16 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@115 $generated@@116) $generated@@1)))) ($generated@@34 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@115 $generated@@116) $generated@@96)) $generated@@93 $generated@@115)) - :pattern ( ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@115 $generated@@116) $generated@@96))) +(assert (forall (($generated@@107 T@U) ($generated@@108 T@U) ) (! (=> (and ($generated@@96 $generated@@107) (and (or (not (= $generated@@108 $generated@@41)) (not true)) (= ($generated@@42 $generated@@108) $generated@@40))) ($generated@@38 $generated@@39 ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@107 $generated@@108) $generated@@52)) $generated@@49)) + :pattern ( ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@107 $generated@@108) $generated@@52))) ))) -(assert ($generated@@98 $generated@@16 $generated@@1)) -(assert (forall (($generated@@117 T@U) ($generated@@118 T@U) ) (! (=> (and ($generated@@103 $generated@@117) (and (or (not (= $generated@@118 $generated@@40)) (not true)) (= ($generated@@87 $generated@@118) $generated@@39))) ($generated@@86 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@117 $generated@@118) $generated@@96)) $generated@@93)) - :pattern ( ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@117 $generated@@118) $generated@@96))) +(assert (forall (($generated@@109 T@U) ) (! (= ($generated@@38 $generated@@39 $generated@@109 $generated@@46) (and ($generated@@38 $generated@@39 $generated@@109 $generated@@40) (or (not (= $generated@@109 $generated@@41)) (not true)))) + :pattern ( ($generated@@38 $generated@@39 $generated@@109 $generated@@46)) ))) -(assert (forall (($generated@@120 T@U) ($generated@@121 T@U) ($generated@@122 T@T) ) (! (= ($generated@@119 $generated@@122 $generated@@120 $generated@@121) (forall (($generated@@123 T@U) ) (! (= ($generated@@20 ($generated@@44 $generated@@122 $generated@@16 $generated@@120 $generated@@123)) ($generated@@20 ($generated@@44 $generated@@122 $generated@@16 $generated@@121 $generated@@123))) - :pattern ( ($generated@@44 $generated@@122 $generated@@16 $generated@@120 $generated@@123)) - :pattern ( ($generated@@44 $generated@@122 $generated@@16 $generated@@121 $generated@@123)) +(assert (forall (($generated@@110 T@U) ) (! (= ($generated@@38 $generated@@39 $generated@@110 $generated@@49) (and ($generated@@38 $generated@@39 $generated@@110 $generated@@44) (or (not (= $generated@@110 $generated@@41)) (not true)))) + :pattern ( ($generated@@38 $generated@@39 $generated@@110 $generated@@49)) ))) - :pattern ( ($generated@@119 $generated@@122 $generated@@120 $generated@@121)) +(assert (forall (($generated@@111 T@U) ($generated@@112 T@U) ) (! (=> (and (and ($generated@@96 $generated@@111) (and (or (not (= $generated@@112 $generated@@41)) (not true)) (= ($generated@@42 $generated@@112) $generated@@40))) ($generated@@20 ($generated@@56 $generated@@16 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@111 $generated@@112) $generated@@1)))) ($generated@@34 $generated@@39 ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@111 $generated@@112) $generated@@52)) $generated@@49 $generated@@111)) + :pattern ( ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@111 $generated@@112) $generated@@52))) ))) -(assert (forall (($generated@@124 T@U) ) (! (= ($generated@@86 $generated@@38 $generated@@124 $generated@@90) (and ($generated@@86 $generated@@38 $generated@@124 $generated@@39) (or (not (= $generated@@124 $generated@@40)) (not true)))) - :pattern ( ($generated@@86 $generated@@38 $generated@@124 $generated@@90)) +(assert (forall (($generated@@113 T@U) ($generated@@114 T@U) ) (! (=> ($generated@@103 $generated@@113 $generated@@114) (= $generated@@113 $generated@@114)) + :pattern ( ($generated@@103 $generated@@113 $generated@@114)) ))) -(assert (forall (($generated@@125 T@U) ) (! (= ($generated@@86 $generated@@38 $generated@@125 $generated@@93) (and ($generated@@86 $generated@@38 $generated@@125 $generated@@83) (or (not (= $generated@@125 $generated@@40)) (not true)))) - :pattern ( ($generated@@86 $generated@@38 $generated@@125 $generated@@93)) +(assert (forall (($generated@@116 T@U) ($generated@@117 T@U) ($generated@@118 T@U) ) (! (=> ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@116 $generated@@118)) ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 ($generated@@115 $generated@@116 $generated@@117) $generated@@118))) + :pattern ( ($generated@@115 $generated@@116 $generated@@117) ($generated@@57 $generated@@59 $generated@@16 $generated@@116 $generated@@118)) ))) -(assert (forall (($generated@@126 T@U) ($generated@@127 T@U) ($generated@@128 T@T) ) (! (=> ($generated@@119 $generated@@128 $generated@@126 $generated@@127) (= $generated@@126 $generated@@127)) - :pattern ( ($generated@@119 $generated@@128 $generated@@126 $generated@@127)) +(assert (forall (($generated@@119 T@U) ($generated@@120 T@U) ($generated@@121 T@U) ) (! (= ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 ($generated@@115 $generated@@119 $generated@@120) $generated@@121)) (or (= $generated@@121 $generated@@120) ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@119 $generated@@121)))) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 ($generated@@115 $generated@@119 $generated@@120) $generated@@121)) ))) -(assert (forall (($generated@@130 T@U) ($generated@@131 T@U) ($generated@@132 T@U) ($generated@@133 T@T) ) (! (=> ($generated@@20 ($generated@@44 $generated@@133 $generated@@16 $generated@@130 $generated@@132)) ($generated@@20 ($generated@@44 $generated@@133 $generated@@16 ($generated@@129 $generated@@133 $generated@@130 $generated@@131) $generated@@132))) - :pattern ( ($generated@@129 $generated@@133 $generated@@130 $generated@@131) ($generated@@44 $generated@@133 $generated@@16 $generated@@130 $generated@@132)) +(assert (forall (($generated@@123 T@U) ($generated@@124 T@U) ) (! (and (= ($generated@@122 ($generated@@53 $generated@@123 $generated@@124)) $generated@@123) (= ($generated@@33 ($generated@@53 $generated@@123 $generated@@124)) $generated@@124)) + :pattern ( ($generated@@53 $generated@@123 $generated@@124)) ))) -(assert (forall (($generated@@134 T@U) ($generated@@135 T@U) ($generated@@136 T@U) ($generated@@137 T@T) ) (! (= ($generated@@20 ($generated@@44 $generated@@137 $generated@@16 ($generated@@129 $generated@@137 $generated@@134 $generated@@135) $generated@@136)) (or (= $generated@@136 $generated@@135) ($generated@@20 ($generated@@44 $generated@@137 $generated@@16 $generated@@134 $generated@@136)))) - :pattern ( ($generated@@44 $generated@@137 $generated@@16 ($generated@@129 $generated@@137 $generated@@134 $generated@@135) $generated@@136)) +(assert (forall (($generated@@125 T@U) ($generated@@126 T@U) ) (! ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 ($generated@@115 $generated@@125 $generated@@126) $generated@@126)) + :pattern ( ($generated@@115 $generated@@125 $generated@@126)) ))) -(assert (forall (($generated@@139 T@U) ($generated@@140 T@U) ($generated@@141 T@T) ) (! (and (= ($generated@@138 $generated@@141 ($generated@@97 $generated@@141 $generated@@139 $generated@@140)) $generated@@139) (= ($generated@@33 $generated@@141 ($generated@@97 $generated@@141 $generated@@139 $generated@@140)) $generated@@140)) - :pattern ( ($generated@@97 $generated@@141 $generated@@139 $generated@@140)) +(assert (forall (($generated@@127 T@U) ($generated@@128 T@T) ) (! (= ($generated@@56 $generated@@128 ($generated@@90 $generated@@128 $generated@@127)) $generated@@127) + :pattern ( ($generated@@90 $generated@@128 $generated@@127)) ))) -(assert (forall (($generated@@142 T@U) ($generated@@143 T@U) ) (! (=> (and ($generated@@103 $generated@@142) (and (or (not (= $generated@@143 $generated@@40)) (not true)) (= ($generated@@87 $generated@@143) $generated@@83))) ($generated@@86 $generated@@17 ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@142 $generated@@143) $generated@@99)) $generated)) - :pattern ( ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@142 $generated@@143) $generated@@99))) +(assert (forall (($generated@@129 T@U) ($generated@@130 T@U) ) (! (=> (and ($generated@@96 $generated@@129) (and (or (not (= $generated@@130 $generated@@41)) (not true)) (= ($generated@@42 $generated@@130) $generated@@44))) ($generated@@38 $generated@@17 ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@129 $generated@@130) $generated@@55)) $generated)) + :pattern ( ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@129 $generated@@130) $generated@@55))) ))) -(assert (forall (($generated@@144 T@U) ($generated@@145 T@U) ($generated@@146 T@T) ) (! ($generated@@20 ($generated@@44 $generated@@146 $generated@@16 ($generated@@129 $generated@@146 $generated@@144 $generated@@145) $generated@@145)) - :pattern ( ($generated@@129 $generated@@146 $generated@@144 $generated@@145)) +(assert (forall (($generated@@132 T@U) ) (! (not ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@131 $generated@@132))) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 $generated@@131 $generated@@132)) ))) -(assert (forall (($generated@@148 T@U) ($generated@@149 T@T) ) (! (= ($generated@@41 $generated@@149 ($generated@@147 $generated@@149 $generated@@148)) $generated@@148) - :pattern ( ($generated@@147 $generated@@149 $generated@@148)) +(assert (forall (($generated@@134 T@U) ($generated@@135 T@U) ) (! (= ($generated@@133 $generated@@134 $generated@@135) (forall (($generated@@136 T@U) ) (! (=> ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@134 $generated@@136)) ($generated@@20 ($generated@@57 $generated@@59 $generated@@16 $generated@@135 $generated@@136))) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 $generated@@134 $generated@@136)) + :pattern ( ($generated@@57 $generated@@59 $generated@@16 $generated@@135 $generated@@136)) ))) -(assert (forall (($generated@@151 T@U) ($generated@@152 T@T) ) (! (not ($generated@@20 ($generated@@44 $generated@@152 $generated@@16 ($generated@@150 $generated@@152) $generated@@151))) - :pattern ( ($generated@@44 $generated@@152 $generated@@16 ($generated@@150 $generated@@152) $generated@@151)) + :pattern ( ($generated@@133 $generated@@134 $generated@@135)) ))) -(assert (and (forall (($generated@@156 T@T) ($generated@@157 T@T) ($generated@@158 T@T) ($generated@@159 T@U) ($generated@@160 T@U) ($generated@@161 T@U) ($generated@@162 T@U) ) (! (= ($generated@@153 $generated@@156 $generated@@157 $generated@@158 ($generated@@155 $generated@@156 $generated@@157 $generated@@158 $generated@@160 $generated@@161 $generated@@162 $generated@@159) $generated@@161 $generated@@162) $generated@@159) - :weight 0 -)) (and (and (forall (($generated@@163 T@T) ($generated@@164 T@T) ($generated@@165 T@T) ($generated@@166 T@T) ($generated@@167 T@U) ($generated@@168 T@U) ($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@U) ($generated@@172 T@U) ) (! (or (= $generated@@165 $generated@@166) (= ($generated@@153 $generated@@166 $generated@@163 $generated@@164 ($generated@@155 $generated@@165 $generated@@163 $generated@@164 $generated@@168 $generated@@169 $generated@@170 $generated@@167) $generated@@171 $generated@@172) ($generated@@153 $generated@@166 $generated@@163 $generated@@164 $generated@@168 $generated@@171 $generated@@172))) +(assert (= ($generated@@32 $generated@@35) $generated@@3)) +(assert (= ($generated@@137 $generated@@35) $generated@@10)) +(assert (= ($generated@@32 $generated@@46) $generated@@4)) +(assert (= ($generated@@137 $generated@@46) $generated@@11)) +(assert (= ($generated@@32 $generated@@40) $generated@@6)) +(assert (= ($generated@@137 $generated@@40) $generated@@11)) +(assert (= ($generated@@32 $generated@@49) $generated@@7)) +(assert (= ($generated@@137 $generated@@49) $generated@@12)) +(assert (= ($generated@@32 $generated@@44) $generated@@9)) +(assert (= ($generated@@137 $generated@@44) $generated@@12)) +(assert (and (forall (($generated@@141 T@T) ($generated@@142 T@T) ($generated@@143 T@T) ($generated@@144 T@U) ($generated@@145 T@U) ($generated@@146 T@U) ($generated@@147 T@U) ) (! (= ($generated@@138 $generated@@141 $generated@@142 $generated@@143 ($generated@@140 $generated@@141 $generated@@142 $generated@@143 $generated@@145 $generated@@146 $generated@@147 $generated@@144) $generated@@146 $generated@@147) $generated@@144) :weight 0 -)) (forall (($generated@@173 T@T) ($generated@@174 T@T) ($generated@@175 T@T) ($generated@@176 T@T) ($generated@@177 T@U) ($generated@@178 T@U) ($generated@@179 T@U) ($generated@@180 T@U) ($generated@@181 T@U) ($generated@@182 T@U) ) (! (or (= $generated@@179 $generated@@181) (= ($generated@@153 $generated@@176 $generated@@173 $generated@@174 ($generated@@155 $generated@@175 $generated@@173 $generated@@174 $generated@@178 $generated@@179 $generated@@180 $generated@@177) $generated@@181 $generated@@182) ($generated@@153 $generated@@176 $generated@@173 $generated@@174 $generated@@178 $generated@@181 $generated@@182))) +)) (and (forall (($generated@@148 T@T) ($generated@@149 T@T) ($generated@@150 T@T) ($generated@@151 T@U) ($generated@@152 T@U) ($generated@@153 T@U) ($generated@@154 T@U) ($generated@@155 T@U) ($generated@@156 T@U) ) (! (or (= $generated@@153 $generated@@155) (= ($generated@@138 $generated@@148 $generated@@149 $generated@@150 ($generated@@140 $generated@@148 $generated@@149 $generated@@150 $generated@@152 $generated@@153 $generated@@154 $generated@@151) $generated@@155 $generated@@156) ($generated@@138 $generated@@148 $generated@@149 $generated@@150 $generated@@152 $generated@@155 $generated@@156))) :weight 0 -))) (forall (($generated@@183 T@T) ($generated@@184 T@T) ($generated@@185 T@T) ($generated@@186 T@T) ($generated@@187 T@U) ($generated@@188 T@U) ($generated@@189 T@U) ($generated@@190 T@U) ($generated@@191 T@U) ($generated@@192 T@U) ) (! (or (= $generated@@190 $generated@@192) (= ($generated@@153 $generated@@186 $generated@@183 $generated@@184 ($generated@@155 $generated@@185 $generated@@183 $generated@@184 $generated@@188 $generated@@189 $generated@@190 $generated@@187) $generated@@191 $generated@@192) ($generated@@153 $generated@@186 $generated@@183 $generated@@184 $generated@@188 $generated@@191 $generated@@192))) +)) (forall (($generated@@157 T@T) ($generated@@158 T@T) ($generated@@159 T@T) ($generated@@160 T@U) ($generated@@161 T@U) ($generated@@162 T@U) ($generated@@163 T@U) ($generated@@164 T@U) ($generated@@165 T@U) ) (! (or (= $generated@@163 $generated@@165) (= ($generated@@138 $generated@@157 $generated@@158 $generated@@159 ($generated@@140 $generated@@157 $generated@@158 $generated@@159 $generated@@161 $generated@@162 $generated@@163 $generated@@160) $generated@@164 $generated@@165) ($generated@@138 $generated@@157 $generated@@158 $generated@@159 $generated@@161 $generated@@164 $generated@@165))) :weight 0 ))))) -(assert (forall (($generated@@193 T@U) ($generated@@194 T@U) ($generated@@195 T@U) ($generated@@196 T@U) ($generated@@197 T@U) ($generated@@198 T@U) ($generated@@199 T@U) ($generated@@200 T@T) ) (! (= ($generated@@20 ($generated@@153 $generated@@200 $generated@@38 $generated@@16 ($generated@@154 $generated@@193 $generated@@194 $generated@@195 $generated@@196 $generated@@197) $generated@@198 $generated@@199)) (=> (and (or (not (= $generated@@198 $generated@@193)) (not true)) ($generated@@20 ($generated@@41 $generated@@16 ($generated@@42 $generated@@16 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@194 $generated@@198) $generated@@195)))) (or (= $generated@@198 $generated@@196) (= $generated@@198 $generated@@197)))) - :pattern ( ($generated@@153 $generated@@200 $generated@@38 $generated@@16 ($generated@@154 $generated@@193 $generated@@194 $generated@@195 $generated@@196 $generated@@197) $generated@@198 $generated@@199)) +(assert (forall (($generated@@166 T@U) ($generated@@167 T@U) ($generated@@168 T@U) ($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@U) ($generated@@172 T@U) ) (! (= ($generated@@20 ($generated@@138 $generated@@39 $generated@@58 $generated@@16 ($generated@@139 $generated@@166 $generated@@167 $generated@@168 $generated@@169 $generated@@170) $generated@@171 $generated@@172)) (=> (and (or (not (= $generated@@171 $generated@@166)) (not true)) ($generated@@20 ($generated@@56 $generated@@16 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@167 $generated@@171) $generated@@168)))) (or (= $generated@@171 $generated@@169) (= $generated@@171 $generated@@170)))) + :pattern ( ($generated@@138 $generated@@39 $generated@@58 $generated@@16 ($generated@@139 $generated@@166 $generated@@167 $generated@@168 $generated@@169 $generated@@170) $generated@@171 $generated@@172)) ))) -(assert (forall (($generated@@202 T@U) ($generated@@203 T@U) ($generated@@204 T@T) ) (! (= ($generated@@201 $generated@@204 $generated@@202 $generated@@203) (forall (($generated@@205 T@U) ) (! (=> ($generated@@20 ($generated@@44 $generated@@204 $generated@@16 $generated@@202 $generated@@205)) ($generated@@20 ($generated@@44 $generated@@204 $generated@@16 $generated@@203 $generated@@205))) - :pattern ( ($generated@@44 $generated@@204 $generated@@16 $generated@@202 $generated@@205)) - :pattern ( ($generated@@44 $generated@@204 $generated@@16 $generated@@203 $generated@@205)) +(assert (forall (($generated@@173 Int) ) (! (= ($generated@@90 $generated@@17 ($generated@@21 ($generated@@85 $generated@@173))) ($generated@@87 $generated@@59 ($generated@@90 $generated@@17 ($generated@@21 $generated@@173)))) + :pattern ( ($generated@@90 $generated@@17 ($generated@@21 ($generated@@85 $generated@@173)))) ))) - :pattern ( ($generated@@201 $generated@@204 $generated@@202 $generated@@203)) +(assert (forall (($generated@@174 T@U) ($generated@@175 T@T) ) (! (= ($generated@@90 $generated@@175 ($generated@@87 $generated@@175 $generated@@174)) ($generated@@87 $generated@@59 ($generated@@90 $generated@@175 $generated@@174))) + :pattern ( ($generated@@90 $generated@@175 ($generated@@87 $generated@@175 $generated@@174))) ))) -(assert (= ($generated@@32 $generated@@35) $generated@@3)) -(assert (= ($generated@@206 $generated@@35) $generated@@10)) -(assert (= ($generated@@32 $generated@@90) $generated@@4)) -(assert (= ($generated@@206 $generated@@90) $generated@@11)) -(assert (= ($generated@@32 $generated@@39) $generated@@6)) -(assert (= ($generated@@206 $generated@@39) $generated@@11)) -(assert (= ($generated@@32 $generated@@93) $generated@@7)) -(assert (= ($generated@@206 $generated@@93) $generated@@12)) -(assert (= ($generated@@32 $generated@@83) $generated@@9)) -(assert (= ($generated@@206 $generated@@83) $generated@@12)) -(assert (forall (($generated@@207 Int) ) (! (= ($generated@@147 $generated@@17 ($generated@@21 ($generated@@104 $generated@@207))) ($generated@@109 $generated@@43 ($generated@@147 $generated@@17 ($generated@@21 $generated@@207)))) - :pattern ( ($generated@@147 $generated@@17 ($generated@@21 ($generated@@104 $generated@@207)))) -))) -(assert (forall (($generated@@208 T@U) ($generated@@209 T@T) ) (! (= ($generated@@147 $generated@@209 ($generated@@109 $generated@@209 $generated@@208)) ($generated@@109 $generated@@43 ($generated@@147 $generated@@209 $generated@@208))) - :pattern ( ($generated@@147 $generated@@209 ($generated@@109 $generated@@209 $generated@@208))) -))) -(assert (=> (<= 1 $generated@@100) (forall (($generated@@210 T@U) ($generated@@211 Int) ($generated@@212 T@U) ) (! (=> (or ($generated@@102 $generated@@210 $generated@@211 $generated@@212) (and (< 1 $generated@@100) (and ($generated@@103 $generated@@210) ($generated@@86 $generated@@38 $generated@@212 $generated@@90)))) (= ($generated@@101 $generated@@210 $generated@@211 $generated@@212) ($generated@@104 3))) - :pattern ( ($generated@@101 $generated@@210 $generated@@211 $generated@@212) ($generated@@103 $generated@@210)) +(assert (=> (<= 1 $generated@@93) (forall (($generated@@176 T@U) ($generated@@177 Int) ($generated@@178 T@U) ) (! (=> (or ($generated@@95 $generated@@176 $generated@@177 $generated@@178) (and (< 1 $generated@@93) (and ($generated@@96 $generated@@176) ($generated@@38 $generated@@39 $generated@@178 $generated@@46)))) (= ($generated@@94 $generated@@176 $generated@@177 $generated@@178) ($generated@@85 3))) + :pattern ( ($generated@@94 $generated@@176 $generated@@177 $generated@@178) ($generated@@96 $generated@@176)) )))) -(assert (forall (($generated@@213 T@U) ($generated@@214 T@U) ) (! ($generated@@34 $generated@@17 $generated@@214 $generated $generated@@213) - :pattern ( ($generated@@34 $generated@@17 $generated@@214 $generated $generated@@213)) +(assert (forall (($generated@@179 T@U) ($generated@@180 T@U) ) (! ($generated@@34 $generated@@17 $generated@@180 $generated $generated@@179) + :pattern ( ($generated@@34 $generated@@17 $generated@@180 $generated $generated@@179)) ))) -(assert (forall (($generated@@215 T@U) ) (! ($generated@@86 $generated@@17 $generated@@215 $generated) - :pattern ( ($generated@@86 $generated@@17 $generated@@215 $generated)) +(assert (forall (($generated@@181 T@U) ) (! ($generated@@38 $generated@@17 $generated@@181 $generated) + :pattern ( ($generated@@38 $generated@@17 $generated@@181 $generated)) ))) (push 1) (declare-fun ControlFlow (Int Int) Int) -(declare-fun $generated@@216 () T@U) -(declare-fun $generated@@217 () Int) -(declare-fun $generated@@218 () T@U) -(declare-fun $generated@@219 () T@U) -(declare-fun $generated@@220 () Bool) -(declare-fun $generated@@221 (T@U) Bool) +(declare-fun $generated@@182 () T@U) +(declare-fun $generated@@183 () Int) +(declare-fun $generated@@184 () T@U) +(declare-fun $generated@@185 () T@U) +(declare-fun $generated@@186 () Bool) +(declare-fun $generated@@187 (T@U) Bool) (set-option :timeout 0) (set-option :rlimit 0) (set-option :auto_config false) @@ -501,12 +497,12 @@ $generated@@185))) (set-option :pp.bv_literals false) (set-option :smt.arith.solver 2) (assert (not - (=> (= (ControlFlow 0 0) 14) (let (($generated@@222 (=> (= (ControlFlow 0 7) (- 0 6)) (= ($generated@@101 $generated@@216 $generated@@217 $generated@@218) ($generated@@22 ($generated@@41 $generated@@17 ($generated@@42 $generated@@17 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))) $generated@@99))))))) -(let (($generated@@223 (and (=> (= (ControlFlow 0 8) (- 0 9)) ($generated@@86 $generated@@17 ($generated@@21 ($generated@@104 3)) $generated@@35)) (=> ($generated@@86 $generated@@17 ($generated@@21 ($generated@@104 3)) $generated@@35) (=> (= ($generated@@101 $generated@@216 $generated@@217 $generated@@218) ($generated@@104 3)) (=> (and ($generated@@86 $generated@@17 ($generated@@21 ($generated@@101 $generated@@216 $generated@@217 $generated@@218)) $generated@@35) (= (ControlFlow 0 8) 7)) $generated@@222)))))) -(let (($generated@@224 (=> (<= ($generated@@104 0) ($generated@@101 $generated@@216 $generated@@217 $generated@@218)) (=> (and ($generated@@34 $generated@@17 ($generated@@21 $generated@@217) $generated $generated@@216) ($generated@@34 $generated@@38 $generated@@218 $generated@@90 $generated@@216)) (and (=> (= (ControlFlow 0 2) (- 0 5)) (or (or (<= 0 $generated@@217) (and ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (not ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))))))) (= $generated@@217 $generated@@217))) (=> (or (or (<= 0 $generated@@217) (and ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (not ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))))))) (= $generated@@217 $generated@@217)) (and (=> (= (ControlFlow 0 2) (- 0 4)) (or (and (= $generated@@217 $generated@@217) (= $generated@@218 $generated@@218)) (or (and ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (not ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))))) (and ($generated@@119 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (or (< $generated@@217 $generated@@217) (and (= $generated@@217 $generated@@217) (and (= $generated@@218 $generated@@40) (or (not (= $generated@@218 $generated@@40)) (not true))))))))) (=> (or (and (= $generated@@217 $generated@@217) (= $generated@@218 $generated@@218)) (or (and ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (not ($generated@@201 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))))) (and ($generated@@119 $generated@@43 ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) ($generated@@129 $generated@@43 ($generated@@129 $generated@@43 ($generated@@150 $generated@@43) ($generated@@147 $generated@@38 $generated@@218)) ($generated@@147 $generated@@38 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96))))) (or (< $generated@@217 $generated@@217) (and (= $generated@@217 $generated@@217) (and (= $generated@@218 $generated@@40) (or (not (= $generated@@218 $generated@@40)) (not true)))))))) (=> (or (and (= $generated@@217 $generated@@217) (= $generated@@218 $generated@@218)) ($generated@@102 $generated@@216 $generated@@217 $generated@@218)) (and (=> (= (ControlFlow 0 2) (- 0 3)) (or (not (= $generated@@218 $generated@@40)) (not true))) (=> (or (not (= $generated@@218 $generated@@40)) (not true)) (=> (= (ControlFlow 0 2) (- 0 1)) (or (not (= ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)) $generated@@40)) (not true)))))))))))))) -(let (($generated@@225 (=> (= $generated@@219 ($generated@@154 $generated@@40 $generated@@216 $generated@@1 $generated@@218 ($generated@@41 $generated@@38 ($generated@@42 $generated@@38 $generated@@43 ($generated@@44 $generated@@38 ($generated@@45 $generated@@43) $generated@@216 $generated@@218) $generated@@96)))) (and (=> (= (ControlFlow 0 10) (- 0 13)) (or (not (= $generated@@218 $generated@@40)) (not true))) (=> (or (not (= $generated@@218 $generated@@40)) (not true)) (=> (= $generated@@220 ($generated@@20 ($generated@@153 $generated@@38 $generated@@38 $generated@@16 $generated@@219 $generated@@218 $generated@@96))) (and (=> (= (ControlFlow 0 10) (- 0 12)) $generated@@220) (=> $generated@@220 (and (=> (= (ControlFlow 0 10) (- 0 11)) (or (not (= $generated@@218 $generated@@40)) (not true))) (=> (or (not (= $generated@@218 $generated@@40)) (not true)) (and (=> (= (ControlFlow 0 10) 2) $generated@@224) (=> (= (ControlFlow 0 10) 8) $generated@@223)))))))))))) -(let (($generated@@226 (=> (and (and (and ($generated@@103 $generated@@216) ($generated@@221 $generated@@216)) ($generated@@86 $generated@@38 $generated@@218 $generated@@90)) (and (= 1 $generated@@100) (= (ControlFlow 0 14) 10))) $generated@@225))) -$generated@@226)))))) + (=> (= (ControlFlow 0 0) 14) (let (($generated@@188 (=> (= (ControlFlow 0 7) (- 0 6)) (= ($generated@@94 $generated@@182 $generated@@183 $generated@@184) ($generated@@22 ($generated@@56 $generated@@17 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) $generated@@55))))))) +(let (($generated@@189 (and (=> (= (ControlFlow 0 8) (- 0 9)) ($generated@@38 $generated@@17 ($generated@@21 ($generated@@85 3)) $generated@@35)) (=> ($generated@@38 $generated@@17 ($generated@@21 ($generated@@85 3)) $generated@@35) (=> (= ($generated@@94 $generated@@182 $generated@@183 $generated@@184) ($generated@@85 3)) (=> (and ($generated@@38 $generated@@17 ($generated@@21 ($generated@@94 $generated@@182 $generated@@183 $generated@@184)) $generated@@35) (= (ControlFlow 0 8) 7)) $generated@@188)))))) +(let (($generated@@190 (=> (<= ($generated@@85 0) ($generated@@94 $generated@@182 $generated@@183 $generated@@184)) (=> (and ($generated@@34 $generated@@17 ($generated@@21 $generated@@183) $generated $generated@@182) ($generated@@34 $generated@@39 $generated@@184 $generated@@46 $generated@@182)) (and (=> (= (ControlFlow 0 2) (- 0 5)) (or (or (<= 0 $generated@@183) (and ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (not ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)))))) (= $generated@@183 $generated@@183))) (=> (or (or (<= 0 $generated@@183) (and ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (not ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)))))) (= $generated@@183 $generated@@183)) (and (=> (= (ControlFlow 0 2) (- 0 4)) (or (and (= $generated@@183 $generated@@183) (= $generated@@184 $generated@@184)) (or (and ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (not ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))))) (and ($generated@@103 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (or (< $generated@@183 $generated@@183) (and (= $generated@@183 $generated@@183) (and (= $generated@@184 $generated@@41) (or (not (= $generated@@184 $generated@@41)) (not true))))))))) (=> (or (and (= $generated@@183 $generated@@183) (= $generated@@184 $generated@@184)) (or (and ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (not ($generated@@133 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))))) (and ($generated@@103 ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) ($generated@@115 ($generated@@115 $generated@@131 ($generated@@90 $generated@@39 $generated@@184)) ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52))) (or (< $generated@@183 $generated@@183) (and (= $generated@@183 $generated@@183) (and (= $generated@@184 $generated@@41) (or (not (= $generated@@184 $generated@@41)) (not true)))))))) (=> (or (and (= $generated@@183 $generated@@183) (= $generated@@184 $generated@@184)) ($generated@@95 $generated@@182 $generated@@183 $generated@@184)) (and (=> (= (ControlFlow 0 2) (- 0 3)) (or (not (= $generated@@184 $generated@@41)) (not true))) (=> (or (not (= $generated@@184 $generated@@41)) (not true)) (=> (= (ControlFlow 0 2) (- 0 1)) (or (not (= ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)) $generated@@41)) (not true)))))))))))))) +(let (($generated@@191 (=> (= $generated@@185 ($generated@@139 $generated@@41 $generated@@182 $generated@@1 $generated@@184 ($generated@@56 $generated@@39 ($generated@@57 $generated@@58 $generated@@59 ($generated@@57 $generated@@39 ($generated@@60 $generated@@58 $generated@@59) $generated@@182 $generated@@184) $generated@@52)))) (and (=> (= (ControlFlow 0 10) (- 0 13)) (or (not (= $generated@@184 $generated@@41)) (not true))) (=> (or (not (= $generated@@184 $generated@@41)) (not true)) (=> (= $generated@@186 ($generated@@20 ($generated@@138 $generated@@39 $generated@@58 $generated@@16 $generated@@185 $generated@@184 $generated@@52))) (and (=> (= (ControlFlow 0 10) (- 0 12)) $generated@@186) (=> $generated@@186 (and (=> (= (ControlFlow 0 10) (- 0 11)) (or (not (= $generated@@184 $generated@@41)) (not true))) (=> (or (not (= $generated@@184 $generated@@41)) (not true)) (and (=> (= (ControlFlow 0 10) 2) $generated@@190) (=> (= (ControlFlow 0 10) 8) $generated@@189)))))))))))) +(let (($generated@@192 (=> (and (and (and ($generated@@96 $generated@@182) ($generated@@187 $generated@@182)) ($generated@@38 $generated@@39 $generated@@184 $generated@@46)) (and (= 1 $generated@@93) (= (ControlFlow 0 14) 10))) $generated@@191))) +$generated@@192)))))) )) (check-sat) (get-info :reason-unknown) @@ -578,81 +574,75 @@ $generated@@226)))))) (declare-fun $generated@@29 (T@U) Int) (declare-fun $generated@@30 (Real) T@U) (declare-fun $generated@@31 (T@U) Real) -(declare-fun $generated@@38 (T@T T@U) Int) +(declare-fun $generated@@38 (T@U) Int) (declare-fun $generated@@39 (T@U) T@U) -(declare-fun $generated@@40 (T@T T@U) T@U) +(declare-fun $generated@@40 (T@U) T@U) (declare-fun $generated@@41 (T@T T@T T@T T@U T@U T@U) T@U) (declare-fun $generated@@42 (T@T T@T) T@T) (declare-fun $generated@@43 () T@T) -(declare-fun $generated@@44 (T@T) T@T) +(declare-fun $generated@@44 () T@T) (declare-fun $generated@@45 () T@T) (declare-fun $generated@@46 (T@U) T@U) -(declare-fun $generated@@47 (T@T T@U T@U) Bool) +(declare-fun $generated@@47 (T@U T@U) Bool) (declare-fun $generated@@48 (T@T T@T T@T T@U T@U T@U T@U) T@U) (declare-fun $generated@@49 (T@T T@T T@U T@U) T@U) (declare-fun $generated@@50 (T@T T@T T@U T@U T@U) T@U) (declare-fun $generated@@51 (T@T) T@T) (declare-fun $generated@@52 (T@T) T@T) -(declare-fun $generated@@53 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@54 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@55 (T@T) T@T) -(declare-fun $generated@@122 (T@U T@U) Bool) -(declare-fun $generated@@123 (T@T T@U) T@U) -(declare-fun $generated@@127 (T@T T@U T@U T@U) Bool) -(declare-fun $generated@@128 () T@U) -(declare-fun $generated@@129 () T@U) -(declare-fun $generated@@132 () T@U) -(declare-fun $generated@@135 () T@U) -(declare-fun $generated@@138 (T@U) Bool) -(declare-fun $generated@@139 (T@U Int T@U) Int) -(declare-fun $generated@@140 (T@U) Bool) -(declare-fun $generated@@141 (T@U Int T@U) Bool) -(declare-fun $generated@@142 (T@T T@U T@U) Bool) -(declare-fun $generated@@143 () T@U) -(declare-fun $generated@@144 () T@U) -(declare-fun $generated@@152 (T@U) T@U) -(declare-fun $generated@@155 () T@T) -(declare-fun $generated@@156 (T@U T@U) T@U) -(declare-fun $generated@@166 () T@U) -(declare-fun $generated@@169 (T@T T@U T@U) T@U) -(declare-fun $generated@@170 (T@T T@U) Bool) -(declare-fun $generated@@171 () T@U) -(declare-fun $generated@@172 () Int) -(declare-fun $generated@@173 (Int) Int) -(declare-fun $generated@@177 (T@U) T@U) -(declare-fun $generated@@182 (T@T T@U) T@U) -(declare-fun $generated@@185 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@186 () T@U) -(declare-fun $generated@@187 (T@T T@U T@U) Bool) -(declare-fun $generated@@188 (T@T) T@U) -(declare-fun $generated@@196 (Int) T@U) -(declare-fun $generated@@197 (T@T T@U) T@U) -(declare-fun $generated@@201 (T@U) T@U) -(declare-fun $generated@@204 (T@T T@U T@U) T@U) -(declare-fun $generated@@205 () T@T) -(declare-fun $generated@@213 (T@T T@U T@U T@U) Bool) -(declare-fun $generated@@231 (T@U T@U) T@U) -(declare-fun $generated@@236 (T@U T@U) T@U) -(declare-fun $generated@@241 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@242 (T@U T@U T@U) T@U) -(declare-fun $generated@@257 (T@U T@U T@U T@U T@U) Bool) -(declare-fun $generated@@269 (Bool) T@U) -(declare-fun $generated@@272 (T@U) T@U) -(declare-fun $generated@@298 (T@T T@U) T@U) -(declare-fun $generated@@315 (T@U) T@U) -(declare-fun $generated@@318 (T@U) T@U) +(declare-fun $generated@@98 (T@T T@U T@U) Bool) +(declare-fun $generated@@99 () T@U) +(declare-fun $generated@@100 () T@U) +(declare-fun $generated@@101 (T@U) T@U) +(declare-fun $generated@@103 () T@U) +(declare-fun $generated@@105 () T@T) +(declare-fun $generated@@106 (T@U T@U) T@U) +(declare-fun $generated@@114 (T@T T@U T@U T@U) Bool) +(declare-fun $generated@@115 () T@U) +(declare-fun $generated@@118 () T@U) +(declare-fun $generated@@121 () T@U) +(declare-fun $generated@@122 (T@U T@U) T@U) +(declare-fun $generated@@123 (T@U) Bool) +(declare-fun $generated@@124 () T@U) +(declare-fun $generated@@125 () T@U) +(declare-fun $generated@@126 (T@T T@U) T@U) +(declare-fun $generated@@133 (T@U T@U) Bool) +(declare-fun $generated@@137 (T@U) T@U) +(declare-fun $generated@@141 (Int) Int) +(declare-fun $generated@@143 (T@T T@U) T@U) +(declare-fun $generated@@146 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@147 () T@U) +(declare-fun $generated@@148 (T@U) Bool) +(declare-fun $generated@@149 (T@U T@U) Bool) +(declare-fun $generated@@150 () T@U) +(declare-fun $generated@@156 (T@U) Bool) +(declare-fun $generated@@157 (T@U Int T@U) Int) +(declare-fun $generated@@158 (T@U Int T@U) Bool) +(declare-fun $generated@@165 (T@T T@U) T@U) +(declare-fun $generated@@168 () Int) +(declare-fun $generated@@172 (Int) T@U) +(declare-fun $generated@@176 (T@U) T@U) +(declare-fun $generated@@179 (T@T T@U T@U) T@U) +(declare-fun $generated@@180 () T@T) +(declare-fun $generated@@186 (T@U T@U T@U) Bool) +(declare-fun $generated@@205 (T@U T@U) T@U) +(declare-fun $generated@@210 (T@U T@U) T@U) +(declare-fun $generated@@215 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@216 (T@U T@U T@U) T@U) +(declare-fun $generated@@233 (T@U T@U T@U T@U T@U) Bool) +(declare-fun $generated@@239 (Bool) T@U) +(declare-fun $generated@@242 (T@U) T@U) +(declare-fun $generated@@267 (T@U) T@U) +(declare-fun $generated@@287 (T@U) T@U) +(declare-fun $generated@@290 (T@U) T@U) +(declare-fun $generated@@293 (T@U) T@U) +(declare-fun $generated@@296 (T@U) T@U) +(declare-fun $generated@@299 (T@U) T@U) +(declare-fun $generated@@302 (T@U) T@U) +(declare-fun $generated@@306 (T@U) T@U) (declare-fun $generated@@321 (T@U) T@U) -(declare-fun $generated@@324 (T@U) T@U) -(declare-fun $generated@@327 (T@U) T@U) -(declare-fun $generated@@330 (T@U) T@U) -(declare-fun $generated@@334 (T@T T@T T@T T@U T@U T@U) T@U) (declare-fun $generated@@335 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@336 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@381 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@389 (T@U) T@U) -(declare-fun $generated@@420 (T@U) T@U) -(declare-fun $generated@@435 (T@U) T@U) -(declare-fun $generated@@494 (T@U) T@U) +(declare-fun $generated@@342 (T@U) T@U) +(declare-fun $generated@@413 (T@U) T@U) (assert (and (and (and (and (and (and (and (and (= ($generated@@22 $generated@@23) 0) (= ($generated@@22 $generated@@24) 1)) (= ($generated@@22 $generated@@25) 2)) (forall (($generated@@32 Bool) ) (! (= ($generated@@27 ($generated@@26 $generated@@32)) $generated@@32) :pattern ( ($generated@@26 $generated@@32)) ))) (forall (($generated@@33 T@U) ) (! (= ($generated@@26 ($generated@@27 $generated@@33)) $generated@@33) @@ -668,366 +658,349 @@ $generated@@226)))))) )))) (assert (distinct $generated $generated@@0 $generated@@1 $generated@@2 $generated@@3 $generated@@4 $generated@@5 $generated@@6 $generated@@7 $generated@@8 $generated@@9 $generated@@10 $generated@@11 $generated@@12 $generated@@13 $generated@@14 $generated@@15 $generated@@16 $generated@@17 $generated@@18 $generated@@19 $generated@@20 $generated@@21) ) -(assert (= ($generated@@38 $generated@@23 $generated@@2) 0)) +(assert (= ($generated@@38 $generated@@2) 0)) (assert (= ($generated@@39 $generated) $generated@@0)) -(assert (= ($generated@@40 $generated@@23 $generated@@2) $generated@@3)) -(assert (and (and (and (and (and (and (and (and (and (and (and (and (forall (($generated@@56 T@T) ($generated@@57 T@T) ($generated@@58 T@T) ($generated@@59 T@U) ($generated@@60 T@U) ($generated@@61 T@U) ($generated@@62 T@U) ) (! (= ($generated@@41 $generated@@56 $generated@@57 $generated@@58 ($generated@@48 $generated@@56 $generated@@57 $generated@@58 $generated@@60 $generated@@61 $generated@@62 $generated@@59) $generated@@61 $generated@@62) $generated@@59) - :weight 0 -)) (and (forall (($generated@@63 T@T) ($generated@@64 T@T) ($generated@@65 T@T) ($generated@@66 T@U) ($generated@@67 T@U) ($generated@@68 T@U) ($generated@@69 T@U) ($generated@@70 T@U) ($generated@@71 T@U) ) (! (or (= $generated@@68 $generated@@70) (= ($generated@@41 $generated@@63 $generated@@64 $generated@@65 ($generated@@48 $generated@@63 $generated@@64 $generated@@65 $generated@@67 $generated@@68 $generated@@69 $generated@@66) $generated@@70 $generated@@71) ($generated@@41 $generated@@63 $generated@@64 $generated@@65 $generated@@67 $generated@@70 $generated@@71))) - :weight 0 -)) (forall (($generated@@72 T@T) ($generated@@73 T@T) ($generated@@74 T@T) ($generated@@75 T@U) ($generated@@76 T@U) ($generated@@77 T@U) ($generated@@78 T@U) ($generated@@79 T@U) ($generated@@80 T@U) ) (! (or (= $generated@@78 $generated@@80) (= ($generated@@41 $generated@@72 $generated@@73 $generated@@74 ($generated@@48 $generated@@72 $generated@@73 $generated@@74 $generated@@76 $generated@@77 $generated@@78 $generated@@75) $generated@@79 $generated@@80) ($generated@@41 $generated@@72 $generated@@73 $generated@@74 $generated@@76 $generated@@79 $generated@@80))) - :weight 0 -)))) (forall (($generated@@81 T@T) ($generated@@82 T@T) ($generated@@83 T@U) ($generated@@84 T@U) ($generated@@85 T@U) ) (! (= ($generated@@49 $generated@@81 $generated@@82 ($generated@@50 $generated@@81 $generated@@82 $generated@@84 $generated@@85 $generated@@83) $generated@@85) $generated@@83) +(assert (= ($generated@@40 $generated@@2) $generated@@3)) +(assert (and (and (and (and (and (and (and (and (and (forall (($generated@@53 T@T) ($generated@@54 T@T) ($generated@@55 T@T) ($generated@@56 T@U) ($generated@@57 T@U) ($generated@@58 T@U) ($generated@@59 T@U) ) (! (= ($generated@@41 $generated@@53 $generated@@54 $generated@@55 ($generated@@48 $generated@@53 $generated@@54 $generated@@55 $generated@@57 $generated@@58 $generated@@59 $generated@@56) $generated@@58 $generated@@59) $generated@@56) :weight 0 -))) (forall (($generated@@86 T@T) ($generated@@87 T@T) ($generated@@88 T@U) ($generated@@89 T@U) ($generated@@90 T@U) ($generated@@91 T@U) ) (! (or (= $generated@@90 $generated@@91) (= ($generated@@49 $generated@@86 $generated@@87 ($generated@@50 $generated@@86 $generated@@87 $generated@@89 $generated@@90 $generated@@88) $generated@@91) ($generated@@49 $generated@@86 $generated@@87 $generated@@89 $generated@@91))) +)) (and (forall (($generated@@60 T@T) ($generated@@61 T@T) ($generated@@62 T@T) ($generated@@63 T@U) ($generated@@64 T@U) ($generated@@65 T@U) ($generated@@66 T@U) ($generated@@67 T@U) ($generated@@68 T@U) ) (! (or (= $generated@@65 $generated@@67) (= ($generated@@41 $generated@@60 $generated@@61 $generated@@62 ($generated@@48 $generated@@60 $generated@@61 $generated@@62 $generated@@64 $generated@@65 $generated@@66 $generated@@63) $generated@@67 $generated@@68) ($generated@@41 $generated@@60 $generated@@61 $generated@@62 $generated@@64 $generated@@67 $generated@@68))) :weight 0 -))) (forall (($generated@@92 T@T) ($generated@@93 T@T) ) (= ($generated@@22 ($generated@@42 $generated@@92 $generated@@93)) 3))) (forall (($generated@@94 T@T) ($generated@@95 T@T) ) (! (= ($generated@@51 ($generated@@42 $generated@@94 $generated@@95)) $generated@@94) - :pattern ( ($generated@@42 $generated@@94 $generated@@95)) -))) (forall (($generated@@96 T@T) ($generated@@97 T@T) ) (! (= ($generated@@52 ($generated@@42 $generated@@96 $generated@@97)) $generated@@97) - :pattern ( ($generated@@42 $generated@@96 $generated@@97)) -))) (= ($generated@@22 $generated@@43) 4)) (forall (($generated@@98 T@T) ($generated@@99 T@T) ($generated@@100 T@U) ($generated@@101 T@U) ($generated@@102 T@U) ) (! (= ($generated@@53 $generated@@98 $generated@@99 ($generated@@54 $generated@@98 $generated@@99 $generated@@101 $generated@@102 $generated@@100) $generated@@102) $generated@@100) +)) (forall (($generated@@69 T@T) ($generated@@70 T@T) ($generated@@71 T@T) ($generated@@72 T@U) ($generated@@73 T@U) ($generated@@74 T@U) ($generated@@75 T@U) ($generated@@76 T@U) ($generated@@77 T@U) ) (! (or (= $generated@@75 $generated@@77) (= ($generated@@41 $generated@@69 $generated@@70 $generated@@71 ($generated@@48 $generated@@69 $generated@@70 $generated@@71 $generated@@73 $generated@@74 $generated@@75 $generated@@72) $generated@@76 $generated@@77) ($generated@@41 $generated@@69 $generated@@70 $generated@@71 $generated@@73 $generated@@76 $generated@@77))) :weight 0 -))) (and (forall (($generated@@103 T@T) ($generated@@104 T@T) ($generated@@105 T@T) ($generated@@106 T@U) ($generated@@107 T@U) ($generated@@108 T@U) ($generated@@109 T@U) ) (! (or (= $generated@@104 $generated@@105) (= ($generated@@53 $generated@@105 $generated@@103 ($generated@@54 $generated@@104 $generated@@103 $generated@@107 $generated@@108 $generated@@106) $generated@@109) ($generated@@53 $generated@@105 $generated@@103 $generated@@107 $generated@@109))) +)))) (forall (($generated@@78 T@T) ($generated@@79 T@T) ($generated@@80 T@U) ($generated@@81 T@U) ($generated@@82 T@U) ) (! (= ($generated@@49 $generated@@78 $generated@@79 ($generated@@50 $generated@@78 $generated@@79 $generated@@81 $generated@@82 $generated@@80) $generated@@82) $generated@@80) :weight 0 -)) (forall (($generated@@110 T@T) ($generated@@111 T@T) ($generated@@112 T@T) ($generated@@113 T@U) ($generated@@114 T@U) ($generated@@115 T@U) ($generated@@116 T@U) ) (! (or (= $generated@@115 $generated@@116) (= ($generated@@53 $generated@@112 $generated@@110 ($generated@@54 $generated@@111 $generated@@110 $generated@@114 $generated@@115 $generated@@113) $generated@@116) ($generated@@53 $generated@@112 $generated@@110 $generated@@114 $generated@@116))) +))) (forall (($generated@@83 T@T) ($generated@@84 T@T) ($generated@@85 T@U) ($generated@@86 T@U) ($generated@@87 T@U) ($generated@@88 T@U) ) (! (or (= $generated@@87 $generated@@88) (= ($generated@@49 $generated@@83 $generated@@84 ($generated@@50 $generated@@83 $generated@@84 $generated@@86 $generated@@87 $generated@@85) $generated@@88) ($generated@@49 $generated@@83 $generated@@84 $generated@@86 $generated@@88))) :weight 0 -)))) (forall (($generated@@117 T@T) ) (= ($generated@@22 ($generated@@44 $generated@@117)) 5))) (forall (($generated@@118 T@T) ) (! (= ($generated@@55 ($generated@@44 $generated@@118)) $generated@@118) - :pattern ( ($generated@@44 $generated@@118)) -))) (= ($generated@@22 $generated@@45) 6))) -(assert (forall (($generated@@119 T@U) ($generated@@120 T@U) ($generated@@121 T@U) ) (! (= ($generated@@27 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@23 ($generated@@46 $generated@@119) $generated@@120 $generated@@121)) ($generated@@47 $generated@@45 $generated@@121 $generated@@119)) - :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@23 ($generated@@46 $generated@@119) $generated@@120 $generated@@121)) -))) -(assert (forall (($generated@@124 T@U) ($generated@@125 T@U) ) (! (=> ($generated@@122 $generated@@124 $generated@@125) (forall (($generated@@126 T@U) ) (! (=> ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@124 $generated@@126) $generated@@2))) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@125 $generated@@126) $generated@@2)))) - :pattern ( ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@125 $generated@@126) $generated@@2))) -))) - :pattern ( ($generated@@122 $generated@@124 $generated@@125)) -))) -(assert (forall (($generated@@130 T@U) ($generated@@131 T@U) ) (! (= ($generated@@127 $generated@@43 $generated@@130 $generated@@128 $generated@@131) (or (= $generated@@130 $generated@@129) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@131 $generated@@130) $generated@@2))))) - :pattern ( ($generated@@127 $generated@@43 $generated@@130 $generated@@128 $generated@@131)) -))) -(assert (forall (($generated@@133 T@U) ($generated@@134 T@U) ) (! (= ($generated@@127 $generated@@43 $generated@@133 $generated@@132 $generated@@134) (or (= $generated@@133 $generated@@129) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@134 $generated@@133) $generated@@2))))) - :pattern ( ($generated@@127 $generated@@43 $generated@@133 $generated@@132 $generated@@134)) -))) -(assert (forall (($generated@@136 T@U) ($generated@@137 T@U) ) (! (= ($generated@@127 $generated@@43 $generated@@136 $generated@@135 $generated@@137) (or (= $generated@@136 $generated@@129) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@137 $generated@@136) $generated@@2))))) - :pattern ( ($generated@@127 $generated@@43 $generated@@136 $generated@@135 $generated@@137)) -))) -(assert (forall (($generated@@145 T@U) ($generated@@146 T@U) ($generated@@147 Int) ($generated@@148 T@U) ) (! (=> (and (and (and ($generated@@140 $generated@@145) ($generated@@140 $generated@@146)) (or ($generated@@141 $generated@@145 $generated@@147 $generated@@148) ($generated@@142 $generated@@43 $generated@@148 $generated@@143))) (and ($generated@@138 $generated@@145) ($generated@@122 $generated@@145 $generated@@146))) (=> (forall (($generated@@149 T@U) ($generated@@150 T@U) ($generated@@151 T@T) ) (=> (and (or (not (= $generated@@149 $generated@@129)) (not true)) (or (= $generated@@149 $generated@@148) (= $generated@@149 ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@145 $generated@@148) $generated@@144))))) (= ($generated@@123 $generated@@151 ($generated@@53 $generated@@151 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@145 $generated@@149) $generated@@150)) ($generated@@123 $generated@@151 ($generated@@53 $generated@@151 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@146 $generated@@149) $generated@@150))))) (= ($generated@@139 $generated@@145 $generated@@147 $generated@@148) ($generated@@139 $generated@@146 $generated@@147 $generated@@148)))) - :pattern ( ($generated@@138 $generated@@145) ($generated@@122 $generated@@145 $generated@@146) ($generated@@139 $generated@@146 $generated@@147 $generated@@148)) -))) -(assert (forall (($generated@@153 T@U) ) (! (= ($generated@@142 $generated@@43 $generated@@153 $generated@@132) (or (= $generated@@153 $generated@@129) (= ($generated@@152 $generated@@153) $generated@@132))) - :pattern ( ($generated@@142 $generated@@43 $generated@@153 $generated@@132)) -))) -(assert (forall (($generated@@154 T@U) ) (! (= ($generated@@142 $generated@@43 $generated@@154 $generated@@135) (or (= $generated@@154 $generated@@129) (= ($generated@@152 $generated@@154) $generated@@135))) - :pattern ( ($generated@@142 $generated@@43 $generated@@154 $generated@@135)) -))) -(assert (= ($generated@@22 $generated@@155) 7)) -(assert (forall (($generated@@157 T@U) ($generated@@158 T@U) ($generated@@159 T@U) ($generated@@160 T@U) ($generated@@161 T@U) ) (! (=> (and (and ($generated@@142 $generated@@155 $generated@@157 ($generated@@156 $generated@@158 $generated@@159)) (forall (($generated@@162 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@162 $generated@@160) ($generated@@47 $generated@@45 $generated@@162 $generated@@158)) - :pattern ( ($generated@@47 $generated@@45 $generated@@162 $generated@@160)) - :pattern ( ($generated@@47 $generated@@45 $generated@@162 $generated@@158)) -))) (forall (($generated@@163 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@163 $generated@@159) ($generated@@47 $generated@@45 $generated@@163 $generated@@161)) - :pattern ( ($generated@@47 $generated@@45 $generated@@163 $generated@@159)) - :pattern ( ($generated@@47 $generated@@45 $generated@@163 $generated@@161)) -))) ($generated@@142 $generated@@155 $generated@@157 ($generated@@156 $generated@@160 $generated@@161))) - :pattern ( ($generated@@142 $generated@@155 $generated@@157 ($generated@@156 $generated@@158 $generated@@159)) ($generated@@142 $generated@@155 $generated@@157 ($generated@@156 $generated@@160 $generated@@161))) -))) -(assert (forall (($generated@@164 T@U) ($generated@@165 T@U) ) (! (= ($generated@@127 $generated@@43 $generated@@164 $generated@@143 $generated@@165) ($generated@@127 $generated@@43 $generated@@164 $generated@@132 $generated@@165)) - :pattern ( ($generated@@127 $generated@@43 $generated@@164 $generated@@143 $generated@@165)) -))) -(assert (forall (($generated@@167 T@U) ($generated@@168 T@U) ) (! (= ($generated@@127 $generated@@43 $generated@@167 $generated@@166 $generated@@168) ($generated@@127 $generated@@43 $generated@@167 $generated@@135 $generated@@168)) - :pattern ( ($generated@@127 $generated@@43 $generated@@167 $generated@@166 $generated@@168)) -))) -(assert (= ($generated@@38 $generated@@43 $generated@@144) 0)) -(assert (= ($generated@@169 $generated@@43 $generated@@9 $generated@@20) $generated@@144)) -(assert (not ($generated@@170 $generated@@43 $generated@@144))) -(assert (= ($generated@@38 $generated@@24 $generated@@171) 0)) -(assert (= ($generated@@169 $generated@@24 $generated@@12 $generated@@21) $generated@@171)) -(assert (not ($generated@@170 $generated@@24 $generated@@171))) -(assert (=> (<= 1 $generated@@172) (forall (($generated@@174 T@U) ($generated@@175 Int) ($generated@@176 T@U) ) (! (=> (or ($generated@@141 $generated@@174 $generated@@175 $generated@@176) (and (< 1 $generated@@172) (and ($generated@@140 $generated@@174) ($generated@@142 $generated@@43 $generated@@176 $generated@@143)))) (and (= ($generated@@139 $generated@@174 $generated@@175 $generated@@176) ($generated@@29 ($generated@@123 $generated@@24 ($generated@@53 $generated@@24 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@174 ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@174 $generated@@176) $generated@@144))) $generated@@171)))) (<= ($generated@@173 0) ($generated@@139 $generated@@174 $generated@@175 $generated@@176)))) - :pattern ( ($generated@@139 $generated@@174 $generated@@175 $generated@@176)) -)))) -(assert (forall (($generated@@178 T@U) ($generated@@179 T@U) ) (! (= ($generated@@142 ($generated@@42 $generated@@45 $generated@@23) $generated@@178 ($generated@@177 $generated@@179)) (forall (($generated@@180 T@U) ) (! (=> ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@178 $generated@@180)) ($generated@@47 $generated@@45 $generated@@180 $generated@@179)) - :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@178 $generated@@180)) +))) (forall (($generated@@89 T@T) ($generated@@90 T@T) ) (= ($generated@@22 ($generated@@42 $generated@@89 $generated@@90)) 3))) (forall (($generated@@91 T@T) ($generated@@92 T@T) ) (! (= ($generated@@51 ($generated@@42 $generated@@91 $generated@@92)) $generated@@91) + :pattern ( ($generated@@42 $generated@@91 $generated@@92)) +))) (forall (($generated@@93 T@T) ($generated@@94 T@T) ) (! (= ($generated@@52 ($generated@@42 $generated@@93 $generated@@94)) $generated@@94) + :pattern ( ($generated@@42 $generated@@93 $generated@@94)) +))) (= ($generated@@22 $generated@@43) 4)) (= ($generated@@22 $generated@@44) 5)) (= ($generated@@22 $generated@@45) 6))) +(assert (forall (($generated@@95 T@U) ($generated@@96 T@U) ($generated@@97 T@U) ) (! (= ($generated@@27 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@23 ($generated@@46 $generated@@95) $generated@@96 $generated@@97)) ($generated@@47 $generated@@97 $generated@@95)) + :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@23 ($generated@@46 $generated@@95) $generated@@96 $generated@@97)) ))) - :pattern ( ($generated@@142 ($generated@@42 $generated@@45 $generated@@23) $generated@@178 ($generated@@177 $generated@@179))) +(assert (forall (($generated@@102 T@U) ) (! (= ($generated@@98 $generated@@43 $generated@@102 $generated@@99) (or (= $generated@@102 $generated@@100) (= ($generated@@101 $generated@@102) $generated@@99))) + :pattern ( ($generated@@98 $generated@@43 $generated@@102 $generated@@99)) ))) -(assert (forall (($generated@@181 Int) ) (! (= ($generated@@173 $generated@@181) $generated@@181) - :pattern ( ($generated@@173 $generated@@181)) +(assert (forall (($generated@@104 T@U) ) (! (= ($generated@@98 $generated@@43 $generated@@104 $generated@@103) (or (= $generated@@104 $generated@@100) (= ($generated@@101 $generated@@104) $generated@@103))) + :pattern ( ($generated@@98 $generated@@43 $generated@@104 $generated@@103)) ))) -(assert (forall (($generated@@183 T@U) ($generated@@184 T@T) ) (! (= ($generated@@182 $generated@@184 $generated@@183) $generated@@183) - :pattern ( ($generated@@182 $generated@@184 $generated@@183)) +(assert (= ($generated@@22 $generated@@105) 7)) +(assert (forall (($generated@@107 T@U) ($generated@@108 T@U) ($generated@@109 T@U) ($generated@@110 T@U) ($generated@@111 T@U) ) (! (=> (and (and ($generated@@98 $generated@@105 $generated@@107 ($generated@@106 $generated@@108 $generated@@109)) (forall (($generated@@112 T@U) ) (! (=> ($generated@@47 $generated@@112 $generated@@110) ($generated@@47 $generated@@112 $generated@@108)) + :pattern ( ($generated@@47 $generated@@112 $generated@@110)) + :pattern ( ($generated@@47 $generated@@112 $generated@@108)) +))) (forall (($generated@@113 T@U) ) (! (=> ($generated@@47 $generated@@113 $generated@@109) ($generated@@47 $generated@@113 $generated@@111)) + :pattern ( ($generated@@47 $generated@@113 $generated@@109)) + :pattern ( ($generated@@47 $generated@@113 $generated@@111)) +))) ($generated@@98 $generated@@105 $generated@@107 ($generated@@106 $generated@@110 $generated@@111))) + :pattern ( ($generated@@98 $generated@@105 $generated@@107 ($generated@@106 $generated@@108 $generated@@109)) ($generated@@98 $generated@@105 $generated@@107 ($generated@@106 $generated@@110 $generated@@111))) ))) -(assert (forall (($generated@@189 T@U) ($generated@@190 T@U) ($generated@@191 T@U) ($generated@@192 T@U) ($generated@@193 T@U) ) (! (=> (and ($generated@@140 $generated@@191) (and ($generated@@47 $generated@@45 $generated@@193 $generated@@189) ($generated@@142 $generated@@155 $generated@@192 ($generated@@156 $generated@@189 $generated@@190)))) (= ($generated@@187 $generated@@45 ($generated@@185 $generated@@189 $generated@@190 $generated@@186 $generated@@192 $generated@@193) ($generated@@188 $generated@@45)) ($generated@@187 $generated@@45 ($generated@@185 $generated@@189 $generated@@190 $generated@@191 $generated@@192 $generated@@193) ($generated@@188 $generated@@45)))) - :pattern ( ($generated@@185 $generated@@189 $generated@@190 $generated@@186 $generated@@192 $generated@@193) ($generated@@140 $generated@@191)) - :pattern ( ($generated@@185 $generated@@189 $generated@@190 $generated@@191 $generated@@192 $generated@@193)) +(assert (forall (($generated@@116 T@U) ($generated@@117 T@U) ) (! (= ($generated@@114 $generated@@43 $generated@@116 $generated@@115 $generated@@117) ($generated@@114 $generated@@43 $generated@@116 $generated@@99 $generated@@117)) + :pattern ( ($generated@@114 $generated@@43 $generated@@116 $generated@@115 $generated@@117)) ))) -(assert (forall (($generated@@194 T@U) ($generated@@195 T@U) ) (! (=> (and (and ($generated@@140 $generated@@194) (and (or (not (= $generated@@195 $generated@@129)) (not true)) (= ($generated@@152 $generated@@195) $generated@@135))) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@194 $generated@@195) $generated@@2)))) ($generated@@127 $generated@@24 ($generated@@123 $generated@@24 ($generated@@53 $generated@@24 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@194 $generated@@195) $generated@@171)) $generated $generated@@194)) - :pattern ( ($generated@@123 $generated@@24 ($generated@@53 $generated@@24 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@194 $generated@@195) $generated@@171))) +(assert (forall (($generated@@119 T@U) ($generated@@120 T@U) ) (! (= ($generated@@114 $generated@@43 $generated@@119 $generated@@118 $generated@@120) ($generated@@114 $generated@@43 $generated@@119 $generated@@103 $generated@@120)) + :pattern ( ($generated@@114 $generated@@43 $generated@@119 $generated@@118 $generated@@120)) ))) -(assert (forall (($generated@@198 Int) ($generated@@199 T@U) ($generated@@200 T@U) ) (! (= ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@45 ($generated@@196 $generated@@198) $generated@@199 $generated@@200) ($generated@@197 $generated@@24 ($generated@@28 (+ ($generated@@29 ($generated@@123 $generated@@24 $generated@@200)) $generated@@198)))) - :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@45 ($generated@@196 $generated@@198) $generated@@199 $generated@@200)) +(assert (= ($generated@@38 $generated@@121) 0)) +(assert (= ($generated@@122 $generated@@9 $generated@@20) $generated@@121)) +(assert (not ($generated@@123 $generated@@121))) +(assert (= ($generated@@38 $generated@@124) 0)) +(assert (= ($generated@@122 $generated@@12 $generated@@21) $generated@@124)) +(assert (not ($generated@@123 $generated@@124))) +(assert (forall (($generated@@127 T@U) ($generated@@128 T@U) ) (! (= ($generated@@114 $generated@@43 $generated@@127 $generated@@125 $generated@@128) (or (= $generated@@127 $generated@@100) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@128 $generated@@127) $generated@@2))))) + :pattern ( ($generated@@114 $generated@@43 $generated@@127 $generated@@125 $generated@@128)) ))) -(assert (forall (($generated@@202 T@U) ($generated@@203 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@201 $generated@@202) $generated@@203)) ($generated@@27 ($generated@@49 $generated@@43 $generated@@23 $generated@@202 ($generated@@123 $generated@@43 $generated@@203)))) - :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@201 $generated@@202) $generated@@203)) +(assert (forall (($generated@@129 T@U) ($generated@@130 T@U) ) (! (= ($generated@@114 $generated@@43 $generated@@129 $generated@@99 $generated@@130) (or (= $generated@@129 $generated@@100) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@130 $generated@@129) $generated@@2))))) + :pattern ( ($generated@@114 $generated@@43 $generated@@129 $generated@@99 $generated@@130)) ))) -(assert (= ($generated@@22 $generated@@205) 8)) -(assert (forall (($generated@@206 T@U) ($generated@@207 T@U) ($generated@@208 T@T) ) (! (= ($generated@@204 $generated@@208 $generated@@206 $generated@@207) ($generated@@49 $generated@@205 $generated@@208 $generated@@206 $generated@@207)) - :pattern ( ($generated@@204 $generated@@208 $generated@@206 $generated@@207)) +(assert (forall (($generated@@131 T@U) ($generated@@132 T@U) ) (! (= ($generated@@114 $generated@@43 $generated@@131 $generated@@103 $generated@@132) (or (= $generated@@131 $generated@@100) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@132 $generated@@131) $generated@@2))))) + :pattern ( ($generated@@114 $generated@@43 $generated@@131 $generated@@103 $generated@@132)) ))) -(assert (forall (($generated@@209 T@U) ($generated@@210 T@U) ) (! (=> (and (and ($generated@@140 $generated@@209) (and (or (not (= $generated@@210 $generated@@129)) (not true)) (= ($generated@@152 $generated@@210) $generated@@132))) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@209 $generated@@210) $generated@@2)))) ($generated@@127 $generated@@43 ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@209 $generated@@210) $generated@@144)) $generated@@166 $generated@@209)) - :pattern ( ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@209 $generated@@210) $generated@@144))) +(assert (forall (($generated@@134 T@U) ($generated@@135 T@U) ) (! (=> ($generated@@133 $generated@@134 $generated@@135) (forall (($generated@@136 T@U) ) (! (=> ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@134 $generated@@136) $generated@@2))) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@135 $generated@@136) $generated@@2)))) + :pattern ( ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@135 $generated@@136) $generated@@2)) ))) -(assert ($generated@@170 $generated@@23 $generated@@2)) -(assert ($generated@@140 $generated@@186)) -(assert (forall (($generated@@211 T@U) ($generated@@212 T@U) ) (! (=> (and ($generated@@140 $generated@@211) (and (or (not (= $generated@@212 $generated@@129)) (not true)) (= ($generated@@152 $generated@@212) $generated@@132))) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@211 $generated@@212) $generated@@144)) $generated@@166)) - :pattern ( ($generated@@123 $generated@@43 ($generated@@53 $generated@@43 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@211 $generated@@212) $generated@@144))) + :pattern ( ($generated@@133 $generated@@134 $generated@@135)) ))) -(assert (forall (($generated@@214 T@U) ($generated@@215 T@U) ($generated@@216 T@U) ($generated@@217 T@T) ) (! (= ($generated@@213 $generated@@45 ($generated@@197 $generated@@217 $generated@@214) $generated@@215 $generated@@216) ($generated@@127 $generated@@217 $generated@@214 $generated@@215 $generated@@216)) - :pattern ( ($generated@@213 $generated@@45 ($generated@@197 $generated@@217 $generated@@214) $generated@@215 $generated@@216)) +(assert (forall (($generated@@138 T@U) ($generated@@139 T@U) ) (! (= ($generated@@98 ($generated@@42 $generated@@45 $generated@@23) $generated@@138 ($generated@@137 $generated@@139)) (forall (($generated@@140 T@U) ) (! (=> ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@138 $generated@@140)) ($generated@@47 $generated@@140 $generated@@139)) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@138 $generated@@140)) ))) -(assert (forall (($generated@@218 T@U) ($generated@@219 T@U) ($generated@@220 T@U) ($generated@@221 T@U) ) (! (=> ($generated@@122 $generated@@218 $generated@@219) (=> ($generated@@213 $generated@@45 $generated@@220 $generated@@221 $generated@@218) ($generated@@213 $generated@@45 $generated@@220 $generated@@221 $generated@@219))) - :pattern ( ($generated@@122 $generated@@218 $generated@@219) ($generated@@213 $generated@@45 $generated@@220 $generated@@221 $generated@@218)) + :pattern ( ($generated@@98 ($generated@@42 $generated@@45 $generated@@23) $generated@@138 ($generated@@137 $generated@@139))) ))) -(assert (forall (($generated@@222 T@U) ($generated@@223 T@U) ($generated@@224 T@U) ($generated@@225 T@U) ($generated@@226 T@T) ) (! (=> ($generated@@122 $generated@@222 $generated@@223) (=> ($generated@@127 $generated@@226 $generated@@224 $generated@@225 $generated@@222) ($generated@@127 $generated@@226 $generated@@224 $generated@@225 $generated@@223))) - :pattern ( ($generated@@122 $generated@@222 $generated@@223) ($generated@@127 $generated@@226 $generated@@224 $generated@@225 $generated@@222)) +(assert (forall (($generated@@142 Int) ) (! (= ($generated@@141 $generated@@142) $generated@@142) + :pattern ( ($generated@@141 $generated@@142)) ))) -(assert (forall (($generated@@227 T@U) ($generated@@228 T@U) ($generated@@229 T@T) ) (! (= ($generated@@187 $generated@@229 $generated@@227 $generated@@228) (forall (($generated@@230 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@229 $generated@@23 $generated@@227 $generated@@230)) ($generated@@27 ($generated@@49 $generated@@229 $generated@@23 $generated@@228 $generated@@230))) - :pattern ( ($generated@@49 $generated@@229 $generated@@23 $generated@@227 $generated@@230)) - :pattern ( ($generated@@49 $generated@@229 $generated@@23 $generated@@228 $generated@@230)) +(assert (forall (($generated@@144 T@U) ($generated@@145 T@T) ) (! (= ($generated@@143 $generated@@145 $generated@@144) $generated@@144) + :pattern ( ($generated@@143 $generated@@145 $generated@@144)) ))) - :pattern ( ($generated@@187 $generated@@229 $generated@@227 $generated@@228)) +(assert (forall (($generated@@151 T@U) ($generated@@152 T@U) ($generated@@153 T@U) ($generated@@154 T@U) ($generated@@155 T@U) ) (! (=> (and ($generated@@148 $generated@@153) (and ($generated@@47 $generated@@155 $generated@@151) ($generated@@98 $generated@@105 $generated@@154 ($generated@@106 $generated@@151 $generated@@152)))) (= ($generated@@149 ($generated@@146 $generated@@151 $generated@@152 $generated@@147 $generated@@154 $generated@@155) $generated@@150) ($generated@@149 ($generated@@146 $generated@@151 $generated@@152 $generated@@153 $generated@@154 $generated@@155) $generated@@150))) + :pattern ( ($generated@@146 $generated@@151 $generated@@152 $generated@@147 $generated@@154 $generated@@155) ($generated@@148 $generated@@153)) + :pattern ( ($generated@@146 $generated@@151 $generated@@152 $generated@@153 $generated@@154 $generated@@155)) ))) -(assert (forall (($generated@@232 T@U) ($generated@@233 T@U) ($generated@@234 T@U) ($generated@@235 T@U) ) (! (= ($generated@@127 $generated@@155 $generated@@234 ($generated@@231 $generated@@232 $generated@@233) $generated@@235) ($generated@@127 $generated@@155 $generated@@234 ($generated@@156 $generated@@232 $generated@@233) $generated@@235)) - :pattern ( ($generated@@127 $generated@@155 $generated@@234 ($generated@@231 $generated@@232 $generated@@233) $generated@@235)) +(assert (forall (($generated@@159 T@U) ($generated@@160 T@U) ($generated@@161 Int) ($generated@@162 T@U) ) (! (=> (and (and (and ($generated@@148 $generated@@159) ($generated@@148 $generated@@160)) (or ($generated@@158 $generated@@159 $generated@@161 $generated@@162) ($generated@@98 $generated@@43 $generated@@162 $generated@@115))) (and ($generated@@156 $generated@@159) ($generated@@133 $generated@@159 $generated@@160))) (=> (forall (($generated@@163 T@U) ($generated@@164 T@U) ) (=> (and (or (not (= $generated@@163 $generated@@100)) (not true)) (or (= $generated@@163 $generated@@162) (= $generated@@163 ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@159 $generated@@162) $generated@@121))))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@159 $generated@@163) $generated@@164) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@160 $generated@@163) $generated@@164)))) (= ($generated@@157 $generated@@159 $generated@@161 $generated@@162) ($generated@@157 $generated@@160 $generated@@161 $generated@@162)))) + :pattern ( ($generated@@156 $generated@@159) ($generated@@133 $generated@@159 $generated@@160) ($generated@@157 $generated@@160 $generated@@161 $generated@@162)) ))) -(assert (forall (($generated@@237 T@U) ($generated@@238 T@U) ($generated@@239 T@U) ($generated@@240 T@U) ) (! (= ($generated@@127 $generated@@155 $generated@@239 ($generated@@236 $generated@@237 $generated@@238) $generated@@240) ($generated@@127 $generated@@155 $generated@@239 ($generated@@231 $generated@@237 $generated@@238) $generated@@240)) - :pattern ( ($generated@@127 $generated@@155 $generated@@239 ($generated@@236 $generated@@237 $generated@@238) $generated@@240)) +(assert (forall (($generated@@166 T@U) ($generated@@167 T@T) ) (! (= ($generated@@165 $generated@@167 ($generated@@126 $generated@@167 $generated@@166)) $generated@@166) + :pattern ( ($generated@@126 $generated@@167 $generated@@166)) ))) -(assert (forall (($generated@@243 T@U) ($generated@@244 T@U) ($generated@@245 T@U) ($generated@@246 T@U) ($generated@@247 T@U) ($generated@@248 T@U) ($generated@@249 T@U) ) (! (= ($generated@@241 $generated@@243 $generated@@244 $generated@@245 ($generated@@242 $generated@@246 $generated@@247 $generated@@248) $generated@@249) ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@45 $generated@@246 $generated@@245 $generated@@249)) - :pattern ( ($generated@@241 $generated@@243 $generated@@244 $generated@@245 ($generated@@242 $generated@@246 $generated@@247 $generated@@248) $generated@@249)) +(assert (=> (<= 1 $generated@@168) (forall (($generated@@169 T@U) ($generated@@170 Int) ($generated@@171 T@U) ) (! (=> (or ($generated@@158 $generated@@169 $generated@@170 $generated@@171) (and (< 1 $generated@@168) (and ($generated@@148 $generated@@169) ($generated@@98 $generated@@43 $generated@@171 $generated@@115)))) (and (= ($generated@@157 $generated@@169 $generated@@170 $generated@@171) ($generated@@29 ($generated@@126 $generated@@24 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@169 ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@169 $generated@@171) $generated@@121))) $generated@@124)))) (<= ($generated@@141 0) ($generated@@157 $generated@@169 $generated@@170 $generated@@171)))) + :pattern ( ($generated@@157 $generated@@169 $generated@@170 $generated@@171)) +)))) +(assert (forall (($generated@@173 Int) ($generated@@174 T@U) ($generated@@175 T@U) ) (! (= ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@45 ($generated@@172 $generated@@173) $generated@@174 $generated@@175) ($generated@@165 $generated@@24 ($generated@@28 (+ ($generated@@29 ($generated@@126 $generated@@24 $generated@@175)) $generated@@173)))) + :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@45 ($generated@@172 $generated@@173) $generated@@174 $generated@@175)) ))) -(assert (forall (($generated@@250 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@250 $generated@@128) (and (= ($generated@@197 $generated@@43 ($generated@@123 $generated@@43 $generated@@250)) $generated@@250) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 $generated@@250) $generated@@128))) - :pattern ( ($generated@@47 $generated@@45 $generated@@250 $generated@@128)) +(assert (forall (($generated@@177 T@U) ($generated@@178 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@176 $generated@@177) $generated@@178)) ($generated@@27 ($generated@@49 $generated@@43 $generated@@23 $generated@@177 ($generated@@126 $generated@@43 $generated@@178)))) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@176 $generated@@177) $generated@@178)) ))) -(assert (forall (($generated@@251 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@251 $generated@@143) (and (= ($generated@@197 $generated@@43 ($generated@@123 $generated@@43 $generated@@251)) $generated@@251) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 $generated@@251) $generated@@143))) - :pattern ( ($generated@@47 $generated@@45 $generated@@251 $generated@@143)) +(assert (= ($generated@@22 $generated@@180) 8)) +(assert (forall (($generated@@181 T@U) ($generated@@182 T@U) ($generated@@183 T@T) ) (! (= ($generated@@179 $generated@@183 $generated@@181 $generated@@182) ($generated@@49 $generated@@180 $generated@@183 $generated@@181 $generated@@182)) + :pattern ( ($generated@@179 $generated@@183 $generated@@181 $generated@@182)) ))) -(assert (forall (($generated@@252 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@252 $generated@@132) (and (= ($generated@@197 $generated@@43 ($generated@@123 $generated@@43 $generated@@252)) $generated@@252) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 $generated@@252) $generated@@132))) - :pattern ( ($generated@@47 $generated@@45 $generated@@252 $generated@@132)) +(assert ($generated@@123 $generated@@2)) +(assert ($generated@@148 $generated@@147)) +(assert (forall (($generated@@184 T@U) ($generated@@185 T@U) ) (! (=> (and (and ($generated@@148 $generated@@184) (and (or (not (= $generated@@185 $generated@@100)) (not true)) (= ($generated@@101 $generated@@185) $generated@@103))) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@184 $generated@@185) $generated@@2)))) ($generated@@114 $generated@@24 ($generated@@126 $generated@@24 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@184 $generated@@185) $generated@@124)) $generated $generated@@184)) + :pattern ( ($generated@@126 $generated@@24 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@184 $generated@@185) $generated@@124))) ))) -(assert (forall (($generated@@253 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@253 $generated@@166) (and (= ($generated@@197 $generated@@43 ($generated@@123 $generated@@43 $generated@@253)) $generated@@253) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 $generated@@253) $generated@@166))) - :pattern ( ($generated@@47 $generated@@45 $generated@@253 $generated@@166)) +(assert (forall (($generated@@187 T@U) ($generated@@188 T@U) ($generated@@189 T@U) ($generated@@190 T@T) ) (! (= ($generated@@186 ($generated@@165 $generated@@190 $generated@@187) $generated@@188 $generated@@189) ($generated@@114 $generated@@190 $generated@@187 $generated@@188 $generated@@189)) + :pattern ( ($generated@@186 ($generated@@165 $generated@@190 $generated@@187) $generated@@188 $generated@@189)) ))) -(assert (forall (($generated@@254 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@254 $generated@@135) (and (= ($generated@@197 $generated@@43 ($generated@@123 $generated@@43 $generated@@254)) $generated@@254) ($generated@@142 $generated@@43 ($generated@@123 $generated@@43 $generated@@254) $generated@@135))) - :pattern ( ($generated@@47 $generated@@45 $generated@@254 $generated@@135)) +(assert (forall (($generated@@191 T@U) ($generated@@192 T@U) ($generated@@193 T@U) ($generated@@194 T@U) ) (! (=> ($generated@@133 $generated@@191 $generated@@192) (=> ($generated@@186 $generated@@193 $generated@@194 $generated@@191) ($generated@@186 $generated@@193 $generated@@194 $generated@@192))) + :pattern ( ($generated@@133 $generated@@191 $generated@@192) ($generated@@186 $generated@@193 $generated@@194 $generated@@191)) ))) -(assert (forall (($generated@@255 T@U) ) (! (= ($generated@@142 $generated@@43 $generated@@255 $generated@@143) (and ($generated@@142 $generated@@43 $generated@@255 $generated@@132) (or (not (= $generated@@255 $generated@@129)) (not true)))) - :pattern ( ($generated@@142 $generated@@43 $generated@@255 $generated@@143)) +(assert (forall (($generated@@195 T@U) ($generated@@196 T@U) ($generated@@197 T@U) ($generated@@198 T@U) ($generated@@199 T@T) ) (! (=> ($generated@@133 $generated@@195 $generated@@196) (=> ($generated@@114 $generated@@199 $generated@@197 $generated@@198 $generated@@195) ($generated@@114 $generated@@199 $generated@@197 $generated@@198 $generated@@196))) + :pattern ( ($generated@@133 $generated@@195 $generated@@196) ($generated@@114 $generated@@199 $generated@@197 $generated@@198 $generated@@195)) ))) -(assert (forall (($generated@@256 T@U) ) (! (= ($generated@@142 $generated@@43 $generated@@256 $generated@@166) (and ($generated@@142 $generated@@43 $generated@@256 $generated@@135) (or (not (= $generated@@256 $generated@@129)) (not true)))) - :pattern ( ($generated@@142 $generated@@43 $generated@@256 $generated@@166)) +(assert (forall (($generated@@200 T@U) ($generated@@201 T@U) ) (! (= ($generated@@149 $generated@@200 $generated@@201) (forall (($generated@@202 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@200 $generated@@202)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@201 $generated@@202))) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@200 $generated@@202)) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@201 $generated@@202)) ))) -(assert (forall (($generated@@258 T@U) ($generated@@259 T@U) ($generated@@260 T@U) ($generated@@261 T@U) ) (! (=> (and ($generated@@140 $generated@@261) ($generated@@127 $generated@@155 $generated@@258 ($generated@@156 $generated@@259 $generated@@260) $generated@@261)) (forall (($generated@@262 T@U) ) (! (=> (and ($generated@@213 $generated@@45 $generated@@262 $generated@@259 $generated@@261) ($generated@@257 $generated@@259 $generated@@260 $generated@@261 $generated@@258 $generated@@262)) ($generated@@213 $generated@@45 ($generated@@241 $generated@@259 $generated@@260 $generated@@261 $generated@@258 $generated@@262) $generated@@260 $generated@@261)) - :pattern ( ($generated@@241 $generated@@259 $generated@@260 $generated@@261 $generated@@258 $generated@@262)) + :pattern ( ($generated@@149 $generated@@200 $generated@@201)) ))) - :pattern ( ($generated@@127 $generated@@155 $generated@@258 ($generated@@156 $generated@@259 $generated@@260) $generated@@261)) +(assert (forall (($generated@@203 T@U) ($generated@@204 T@U) ) (! (=> (and ($generated@@148 $generated@@203) (and (or (not (= $generated@@204 $generated@@100)) (not true)) (= ($generated@@101 $generated@@204) $generated@@99))) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@203 $generated@@204) $generated@@121)) $generated@@118)) + :pattern ( ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@203 $generated@@204) $generated@@121))) ))) -(assert (forall (($generated@@263 T@U) ($generated@@264 T@U) ($generated@@265 T@U) ($generated@@266 T@U) ) (! (=> ($generated@@140 $generated@@266) (= ($generated@@127 $generated@@155 $generated@@263 ($generated@@156 $generated@@264 $generated@@265) $generated@@266) (forall (($generated@@267 T@U) ) (! (=> (and (and ($generated@@47 $generated@@45 $generated@@267 $generated@@264) ($generated@@213 $generated@@45 $generated@@267 $generated@@264 $generated@@266)) ($generated@@257 $generated@@264 $generated@@265 $generated@@266 $generated@@263 $generated@@267)) (forall (($generated@@268 T@U) ) (! (=> (and (or (not (= $generated@@268 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@264 $generated@@265 $generated@@266 $generated@@263 $generated@@267) ($generated@@197 $generated@@43 $generated@@268)))) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@266 $generated@@268) $generated@@2)))) - :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@264 $generated@@265 $generated@@266 $generated@@263 $generated@@267) ($generated@@197 $generated@@43 $generated@@268))) +(assert (forall (($generated@@206 T@U) ($generated@@207 T@U) ($generated@@208 T@U) ($generated@@209 T@U) ) (! (= ($generated@@114 $generated@@105 $generated@@208 ($generated@@205 $generated@@206 $generated@@207) $generated@@209) ($generated@@114 $generated@@105 $generated@@208 ($generated@@106 $generated@@206 $generated@@207) $generated@@209)) + :pattern ( ($generated@@114 $generated@@105 $generated@@208 ($generated@@205 $generated@@206 $generated@@207) $generated@@209)) ))) - :pattern ( ($generated@@241 $generated@@264 $generated@@265 $generated@@266 $generated@@263 $generated@@267)) - :pattern ( ($generated@@185 $generated@@264 $generated@@265 $generated@@266 $generated@@263 $generated@@267)) -)))) - :pattern ( ($generated@@127 $generated@@155 $generated@@263 ($generated@@156 $generated@@264 $generated@@265) $generated@@266)) +(assert (forall (($generated@@211 T@U) ($generated@@212 T@U) ($generated@@213 T@U) ($generated@@214 T@U) ) (! (= ($generated@@114 $generated@@105 $generated@@213 ($generated@@210 $generated@@211 $generated@@212) $generated@@214) ($generated@@114 $generated@@105 $generated@@213 ($generated@@205 $generated@@211 $generated@@212) $generated@@214)) + :pattern ( ($generated@@114 $generated@@105 $generated@@213 ($generated@@210 $generated@@211 $generated@@212) $generated@@214)) ))) -(assert (forall (($generated@@270 Bool) ($generated@@271 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@43 $generated@@23 ($generated@@269 $generated@@270) $generated@@271)) $generated@@270) - :pattern ( ($generated@@49 $generated@@43 $generated@@23 ($generated@@269 $generated@@270) $generated@@271)) +(assert (forall (($generated@@217 T@U) ($generated@@218 T@U) ($generated@@219 T@U) ($generated@@220 T@U) ($generated@@221 T@U) ($generated@@222 T@U) ($generated@@223 T@U) ) (! (= ($generated@@215 $generated@@217 $generated@@218 $generated@@219 ($generated@@216 $generated@@220 $generated@@221 $generated@@222) $generated@@223) ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@45 $generated@@220 $generated@@219 $generated@@223)) + :pattern ( ($generated@@215 $generated@@217 $generated@@218 $generated@@219 ($generated@@216 $generated@@220 $generated@@221 $generated@@222) $generated@@223)) ))) -(assert (forall (($generated@@273 T@U) ($generated@@274 T@U) ) (! (= ($generated@@49 $generated@@205 $generated@@155 ($generated@@272 $generated@@273) $generated@@274) $generated@@273) - :pattern ( ($generated@@49 $generated@@205 $generated@@155 ($generated@@272 $generated@@273) $generated@@274)) +(assert (forall (($generated@@224 T@U) ) (! (=> ($generated@@47 $generated@@224 $generated@@125) (and (= ($generated@@165 $generated@@43 ($generated@@126 $generated@@43 $generated@@224)) $generated@@224) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 $generated@@224) $generated@@125))) + :pattern ( ($generated@@47 $generated@@224 $generated@@125)) ))) -(assert (forall (($generated@@275 T@U) ($generated@@276 T@U) ($generated@@277 T@U) ) (! (= ($generated@@127 ($generated@@42 $generated@@45 $generated@@23) $generated@@275 ($generated@@177 $generated@@276) $generated@@277) (forall (($generated@@278 T@U) ) (! (=> ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@275 $generated@@278)) ($generated@@213 $generated@@45 $generated@@278 $generated@@276 $generated@@277)) - :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@275 $generated@@278)) +(assert (forall (($generated@@225 T@U) ) (! (=> ($generated@@47 $generated@@225 $generated@@115) (and (= ($generated@@165 $generated@@43 ($generated@@126 $generated@@43 $generated@@225)) $generated@@225) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 $generated@@225) $generated@@115))) + :pattern ( ($generated@@47 $generated@@225 $generated@@115)) ))) - :pattern ( ($generated@@127 ($generated@@42 $generated@@45 $generated@@23) $generated@@275 ($generated@@177 $generated@@276) $generated@@277)) +(assert (forall (($generated@@226 T@U) ) (! (=> ($generated@@47 $generated@@226 $generated@@99) (and (= ($generated@@165 $generated@@43 ($generated@@126 $generated@@43 $generated@@226)) $generated@@226) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 $generated@@226) $generated@@99))) + :pattern ( ($generated@@47 $generated@@226 $generated@@99)) ))) -(assert (forall (($generated@@279 T@U) ($generated@@280 T@U) ($generated@@281 T@U) ($generated@@282 T@U) ($generated@@283 T@U) ($generated@@284 T@U) ($generated@@285 T@U) ($generated@@286 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@279 $generated@@280 $generated@@281 ($generated@@242 $generated@@282 $generated@@283 $generated@@284) $generated@@285) $generated@@286)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) $generated@@284 $generated@@281 $generated@@285) $generated@@286))) - :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@279 $generated@@280 $generated@@281 ($generated@@242 $generated@@282 $generated@@283 $generated@@284) $generated@@285) $generated@@286)) +(assert (forall (($generated@@227 T@U) ) (! (=> ($generated@@47 $generated@@227 $generated@@118) (and (= ($generated@@165 $generated@@43 ($generated@@126 $generated@@43 $generated@@227)) $generated@@227) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 $generated@@227) $generated@@118))) + :pattern ( ($generated@@47 $generated@@227 $generated@@118)) ))) -(assert (forall (($generated@@287 T@U) ($generated@@288 T@U) ($generated@@289 T@T) ) (! (=> ($generated@@187 $generated@@289 $generated@@287 $generated@@288) (= $generated@@287 $generated@@288)) - :pattern ( ($generated@@187 $generated@@289 $generated@@287 $generated@@288)) +(assert (forall (($generated@@228 T@U) ) (! (=> ($generated@@47 $generated@@228 $generated@@103) (and (= ($generated@@165 $generated@@43 ($generated@@126 $generated@@43 $generated@@228)) $generated@@228) ($generated@@98 $generated@@43 ($generated@@126 $generated@@43 $generated@@228) $generated@@103))) + :pattern ( ($generated@@47 $generated@@228 $generated@@103)) ))) -(assert (forall (($generated@@290 T@U) ($generated@@291 T@U) ($generated@@292 T@U) ) (! (=> (or (not (= $generated@@290 $generated@@292)) (not true)) (=> (and ($generated@@122 $generated@@290 $generated@@291) ($generated@@122 $generated@@291 $generated@@292)) ($generated@@122 $generated@@290 $generated@@292))) - :pattern ( ($generated@@122 $generated@@290 $generated@@291) ($generated@@122 $generated@@291 $generated@@292)) +(assert (forall (($generated@@229 T@U) ) (! (= ($generated@@98 $generated@@43 $generated@@229 $generated@@115) (and ($generated@@98 $generated@@43 $generated@@229 $generated@@99) (or (not (= $generated@@229 $generated@@100)) (not true)))) + :pattern ( ($generated@@98 $generated@@43 $generated@@229 $generated@@115)) ))) -(assert (forall (($generated@@293 T@U) ($generated@@294 T@U) ($generated@@295 T@U) ) (! (= ($generated@@142 $generated@@155 $generated@@293 ($generated@@156 $generated@@294 $generated@@295)) (forall (($generated@@296 T@U) ($generated@@297 T@U) ) (! (=> (and (and ($generated@@140 $generated@@296) ($generated@@47 $generated@@45 $generated@@297 $generated@@294)) ($generated@@257 $generated@@294 $generated@@295 $generated@@296 $generated@@293 $generated@@297)) ($generated@@47 $generated@@45 ($generated@@241 $generated@@294 $generated@@295 $generated@@296 $generated@@293 $generated@@297) $generated@@295)) - :pattern ( ($generated@@241 $generated@@294 $generated@@295 $generated@@296 $generated@@293 $generated@@297)) +(assert (forall (($generated@@230 T@U) ) (! (= ($generated@@98 $generated@@43 $generated@@230 $generated@@118) (and ($generated@@98 $generated@@43 $generated@@230 $generated@@103) (or (not (= $generated@@230 $generated@@100)) (not true)))) + :pattern ( ($generated@@98 $generated@@43 $generated@@230 $generated@@118)) ))) - :pattern ( ($generated@@142 $generated@@155 $generated@@293 ($generated@@156 $generated@@294 $generated@@295))) +(assert (forall (($generated@@231 T@U) ($generated@@232 T@U) ) (! (=> (and (and ($generated@@148 $generated@@231) (and (or (not (= $generated@@232 $generated@@100)) (not true)) (= ($generated@@101 $generated@@232) $generated@@99))) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@231 $generated@@232) $generated@@2)))) ($generated@@114 $generated@@43 ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@231 $generated@@232) $generated@@121)) $generated@@118 $generated@@231)) + :pattern ( ($generated@@126 $generated@@43 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@231 $generated@@232) $generated@@121))) ))) -(assert (forall (($generated@@299 T@U) ($generated@@300 T@U) ($generated@@301 T@T) ) (! (and (= ($generated@@298 $generated@@301 ($generated@@169 $generated@@301 $generated@@299 $generated@@300)) $generated@@299) (= ($generated@@40 $generated@@301 ($generated@@169 $generated@@301 $generated@@299 $generated@@300)) $generated@@300)) - :pattern ( ($generated@@169 $generated@@301 $generated@@299 $generated@@300)) +(assert (forall (($generated@@234 T@U) ($generated@@235 T@U) ($generated@@236 T@U) ($generated@@237 T@U) ) (! (=> (and ($generated@@148 $generated@@237) ($generated@@114 $generated@@105 $generated@@234 ($generated@@106 $generated@@235 $generated@@236) $generated@@237)) (forall (($generated@@238 T@U) ) (! (=> (and ($generated@@186 $generated@@238 $generated@@235 $generated@@237) ($generated@@233 $generated@@235 $generated@@236 $generated@@237 $generated@@234 $generated@@238)) ($generated@@186 ($generated@@215 $generated@@235 $generated@@236 $generated@@237 $generated@@234 $generated@@238) $generated@@236 $generated@@237)) + :pattern ( ($generated@@215 $generated@@235 $generated@@236 $generated@@237 $generated@@234 $generated@@238)) ))) -(assert (forall (($generated@@302 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@302 $generated) (and (= ($generated@@197 $generated@@24 ($generated@@123 $generated@@24 $generated@@302)) $generated@@302) ($generated@@142 $generated@@24 ($generated@@123 $generated@@24 $generated@@302) $generated))) - :pattern ( ($generated@@47 $generated@@45 $generated@@302 $generated)) + :pattern ( ($generated@@114 $generated@@105 $generated@@234 ($generated@@106 $generated@@235 $generated@@236) $generated@@237)) ))) -(assert (forall (($generated@@303 T@U) ($generated@@304 T@U) ($generated@@305 T@T) ) (! (= ($generated@@47 $generated@@45 ($generated@@197 $generated@@305 $generated@@303) $generated@@304) ($generated@@142 $generated@@305 $generated@@303 $generated@@304)) - :pattern ( ($generated@@47 $generated@@45 ($generated@@197 $generated@@305 $generated@@303) $generated@@304)) +(assert (forall (($generated@@240 Bool) ($generated@@241 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@43 $generated@@23 ($generated@@239 $generated@@240) $generated@@241)) $generated@@240) + :pattern ( ($generated@@49 $generated@@43 $generated@@23 ($generated@@239 $generated@@240) $generated@@241)) ))) -(assert (forall (($generated@@306 T@U) ($generated@@307 T@U) ($generated@@308 T@U) ($generated@@309 T@U) ($generated@@310 T@U) ($generated@@311 T@U) ($generated@@312 T@U) ) (! (=> ($generated@@27 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 $generated@@23 $generated@@310 $generated@@308 $generated@@312)) ($generated@@257 $generated@@306 $generated@@307 $generated@@308 ($generated@@242 $generated@@309 $generated@@310 $generated@@311) $generated@@312)) - :pattern ( ($generated@@257 $generated@@306 $generated@@307 $generated@@308 ($generated@@242 $generated@@309 $generated@@310 $generated@@311) $generated@@312)) +(assert (forall (($generated@@243 T@U) ($generated@@244 T@U) ) (! (= ($generated@@49 $generated@@180 $generated@@105 ($generated@@242 $generated@@243) $generated@@244) $generated@@243) + :pattern ( ($generated@@49 $generated@@180 $generated@@105 ($generated@@242 $generated@@243) $generated@@244)) ))) -(assert (forall (($generated@@313 T@U) ($generated@@314 T@U) ) (! (=> (and ($generated@@140 $generated@@313) (and (or (not (= $generated@@314 $generated@@129)) (not true)) (= ($generated@@152 $generated@@314) $generated@@135))) ($generated@@142 $generated@@24 ($generated@@123 $generated@@24 ($generated@@53 $generated@@24 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@313 $generated@@314) $generated@@171)) $generated)) - :pattern ( ($generated@@123 $generated@@24 ($generated@@53 $generated@@24 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@313 $generated@@314) $generated@@171))) +(assert (forall (($generated@@245 T@U) ($generated@@246 T@U) ($generated@@247 T@U) ) (! (= ($generated@@114 ($generated@@42 $generated@@45 $generated@@23) $generated@@245 ($generated@@137 $generated@@246) $generated@@247) (forall (($generated@@248 T@U) ) (! (=> ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@245 $generated@@248)) ($generated@@186 $generated@@248 $generated@@246 $generated@@247)) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@245 $generated@@248)) ))) -(assert (forall (($generated@@316 T@U) ($generated@@317 T@U) ) (! (= ($generated@@315 ($generated@@156 $generated@@316 $generated@@317)) $generated@@316) - :pattern ( ($generated@@156 $generated@@316 $generated@@317)) + :pattern ( ($generated@@114 ($generated@@42 $generated@@45 $generated@@23) $generated@@245 ($generated@@137 $generated@@246) $generated@@247)) ))) -(assert (forall (($generated@@319 T@U) ($generated@@320 T@U) ) (! (= ($generated@@318 ($generated@@156 $generated@@319 $generated@@320)) $generated@@320) - :pattern ( ($generated@@156 $generated@@319 $generated@@320)) +(assert (forall (($generated@@249 T@U) ($generated@@250 T@U) ($generated@@251 T@U) ($generated@@252 T@U) ($generated@@253 T@U) ($generated@@254 T@U) ($generated@@255 T@U) ($generated@@256 T@U) ) (! (= ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@249 $generated@@250 $generated@@251 ($generated@@216 $generated@@252 $generated@@253 $generated@@254) $generated@@255) $generated@@256)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) $generated@@254 $generated@@251 $generated@@255) $generated@@256))) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@249 $generated@@250 $generated@@251 ($generated@@216 $generated@@252 $generated@@253 $generated@@254) $generated@@255) $generated@@256)) ))) -(assert (forall (($generated@@322 T@U) ($generated@@323 T@U) ) (! (= ($generated@@321 ($generated@@231 $generated@@322 $generated@@323)) $generated@@322) - :pattern ( ($generated@@231 $generated@@322 $generated@@323)) +(assert (forall (($generated@@257 T@U) ($generated@@258 T@U) ) (! (=> ($generated@@149 $generated@@257 $generated@@258) (= $generated@@257 $generated@@258)) + :pattern ( ($generated@@149 $generated@@257 $generated@@258)) ))) -(assert (forall (($generated@@325 T@U) ($generated@@326 T@U) ) (! (= ($generated@@324 ($generated@@231 $generated@@325 $generated@@326)) $generated@@326) - :pattern ( ($generated@@231 $generated@@325 $generated@@326)) +(assert (forall (($generated@@259 T@U) ($generated@@260 T@U) ($generated@@261 T@U) ) (! (=> (or (not (= $generated@@259 $generated@@261)) (not true)) (=> (and ($generated@@133 $generated@@259 $generated@@260) ($generated@@133 $generated@@260 $generated@@261)) ($generated@@133 $generated@@259 $generated@@261))) + :pattern ( ($generated@@133 $generated@@259 $generated@@260) ($generated@@133 $generated@@260 $generated@@261)) ))) -(assert (forall (($generated@@328 T@U) ($generated@@329 T@U) ) (! (= ($generated@@327 ($generated@@236 $generated@@328 $generated@@329)) $generated@@328) - :pattern ( ($generated@@236 $generated@@328 $generated@@329)) +(assert (forall (($generated@@262 T@U) ($generated@@263 T@U) ($generated@@264 T@U) ) (! (= ($generated@@98 $generated@@105 $generated@@262 ($generated@@106 $generated@@263 $generated@@264)) (forall (($generated@@265 T@U) ($generated@@266 T@U) ) (! (=> (and (and ($generated@@148 $generated@@265) ($generated@@47 $generated@@266 $generated@@263)) ($generated@@233 $generated@@263 $generated@@264 $generated@@265 $generated@@262 $generated@@266)) ($generated@@47 ($generated@@215 $generated@@263 $generated@@264 $generated@@265 $generated@@262 $generated@@266) $generated@@264)) + :pattern ( ($generated@@215 $generated@@263 $generated@@264 $generated@@265 $generated@@262 $generated@@266)) ))) -(assert (forall (($generated@@331 T@U) ($generated@@332 T@U) ) (! (= ($generated@@330 ($generated@@236 $generated@@331 $generated@@332)) $generated@@332) - :pattern ( ($generated@@236 $generated@@331 $generated@@332)) + :pattern ( ($generated@@98 $generated@@105 $generated@@262 ($generated@@106 $generated@@263 $generated@@264))) ))) -(assert (forall (($generated@@333 T@U) ) (! ($generated@@142 $generated@@43 $generated@@333 $generated@@128) - :pattern ( ($generated@@142 $generated@@43 $generated@@333 $generated@@128)) +(assert (forall (($generated@@268 T@U) ($generated@@269 T@U) ) (! (and (= ($generated@@267 ($generated@@122 $generated@@268 $generated@@269)) $generated@@268) (= ($generated@@40 ($generated@@122 $generated@@268 $generated@@269)) $generated@@269)) + :pattern ( ($generated@@122 $generated@@268 $generated@@269)) ))) -(assert (and (forall (($generated@@337 T@T) ($generated@@338 T@T) ($generated@@339 T@T) ($generated@@340 T@U) ($generated@@341 T@U) ($generated@@342 T@U) ($generated@@343 T@U) ) (! (= ($generated@@334 $generated@@337 $generated@@338 $generated@@339 ($generated@@336 $generated@@337 $generated@@338 $generated@@339 $generated@@341 $generated@@342 $generated@@343 $generated@@340) $generated@@342 $generated@@343) $generated@@340) - :weight 0 -)) (and (and (forall (($generated@@344 T@T) ($generated@@345 T@T) ($generated@@346 T@T) ($generated@@347 T@T) ($generated@@348 T@U) ($generated@@349 T@U) ($generated@@350 T@U) ($generated@@351 T@U) ($generated@@352 T@U) ($generated@@353 T@U) ) (! (or (= $generated@@346 $generated@@347) (= ($generated@@334 $generated@@347 $generated@@344 $generated@@345 ($generated@@336 $generated@@346 $generated@@344 $generated@@345 $generated@@349 $generated@@350 $generated@@351 $generated@@348) $generated@@352 $generated@@353) ($generated@@334 $generated@@347 $generated@@344 $generated@@345 $generated@@349 $generated@@352 $generated@@353))) - :weight 0 -)) (forall (($generated@@354 T@T) ($generated@@355 T@T) ($generated@@356 T@T) ($generated@@357 T@T) ($generated@@358 T@U) ($generated@@359 T@U) ($generated@@360 T@U) ($generated@@361 T@U) ($generated@@362 T@U) ($generated@@363 T@U) ) (! (or (= $generated@@360 $generated@@362) (= ($generated@@334 $generated@@357 $generated@@354 $generated@@355 ($generated@@336 $generated@@356 $generated@@354 $generated@@355 $generated@@359 $generated@@360 $generated@@361 $generated@@358) $generated@@362 $generated@@363) ($generated@@334 $generated@@357 $generated@@354 $generated@@355 $generated@@359 $generated@@362 $generated@@363))) - :weight 0 -))) (forall (($generated@@364 T@T) ($generated@@365 T@T) ($generated@@366 T@T) ($generated@@367 T@T) ($generated@@368 T@U) ($generated@@369 T@U) ($generated@@370 T@U) ($generated@@371 T@U) ($generated@@372 T@U) ($generated@@373 T@U) ) (! (or (= $generated@@371 $generated@@373) (= ($generated@@334 $generated@@367 $generated@@364 $generated@@365 ($generated@@336 $generated@@366 $generated@@364 $generated@@365 $generated@@369 $generated@@370 $generated@@371 $generated@@368) $generated@@372 $generated@@373) ($generated@@334 $generated@@367 $generated@@364 $generated@@365 $generated@@369 $generated@@372 $generated@@373))) - :weight 0 -))))) -(assert (forall (($generated@@374 T@U) ($generated@@375 T@U) ($generated@@376 T@U) ($generated@@377 Bool) ($generated@@378 T@U) ($generated@@379 T@U) ($generated@@380 T@T) ) (! (= ($generated@@27 ($generated@@334 $generated@@380 $generated@@43 $generated@@23 ($generated@@335 $generated@@374 $generated@@375 $generated@@376 $generated@@377) $generated@@378 $generated@@379)) (=> (and (or (not (= $generated@@378 $generated@@374)) (not true)) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@375 $generated@@378) $generated@@376)))) $generated@@377)) - :pattern ( ($generated@@334 $generated@@380 $generated@@43 $generated@@23 ($generated@@335 $generated@@374 $generated@@375 $generated@@376 $generated@@377) $generated@@378 $generated@@379)) +(assert (forall (($generated@@270 T@U) ($generated@@271 T@U) ($generated@@272 T@U) ($generated@@273 T@U) ) (! (=> ($generated@@148 $generated@@273) (= ($generated@@114 $generated@@105 $generated@@270 ($generated@@106 $generated@@271 $generated@@272) $generated@@273) (forall (($generated@@274 T@U) ) (! (=> (and (and ($generated@@47 $generated@@274 $generated@@271) ($generated@@186 $generated@@274 $generated@@271 $generated@@273)) ($generated@@233 $generated@@271 $generated@@272 $generated@@273 $generated@@270 $generated@@274)) (forall (($generated@@275 T@U) ) (! (=> (and (or (not (= $generated@@275 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@271 $generated@@272 $generated@@273 $generated@@270 $generated@@274) ($generated@@165 $generated@@43 $generated@@275)))) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@273 $generated@@275) $generated@@2)))) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@271 $generated@@272 $generated@@273 $generated@@270 $generated@@274) ($generated@@165 $generated@@43 $generated@@275))) +))) + :pattern ( ($generated@@215 $generated@@271 $generated@@272 $generated@@273 $generated@@270 $generated@@274)) + :pattern ( ($generated@@146 $generated@@271 $generated@@272 $generated@@273 $generated@@270 $generated@@274)) +)))) + :pattern ( ($generated@@114 $generated@@105 $generated@@270 ($generated@@106 $generated@@271 $generated@@272) $generated@@273)) ))) -(assert (forall (($generated@@382 T@U) ($generated@@383 T@U) ($generated@@384 T@U) ($generated@@385 Bool) ($generated@@386 T@U) ($generated@@387 T@U) ($generated@@388 T@T) ) (! (= ($generated@@27 ($generated@@334 $generated@@388 $generated@@43 $generated@@23 ($generated@@381 $generated@@382 $generated@@383 $generated@@384 $generated@@385) $generated@@386 $generated@@387)) (=> (and (or (not (= $generated@@386 $generated@@382)) (not true)) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@383 $generated@@386) $generated@@384)))) $generated@@385)) - :pattern ( ($generated@@334 $generated@@388 $generated@@43 $generated@@23 ($generated@@381 $generated@@382 $generated@@383 $generated@@384 $generated@@385) $generated@@386 $generated@@387)) +(assert (forall (($generated@@276 T@U) ) (! (=> ($generated@@47 $generated@@276 $generated) (and (= ($generated@@165 $generated@@24 ($generated@@126 $generated@@24 $generated@@276)) $generated@@276) ($generated@@98 $generated@@24 ($generated@@126 $generated@@24 $generated@@276) $generated))) + :pattern ( ($generated@@47 $generated@@276 $generated)) ))) -(assert (forall (($generated@@390 T@U) ) (! (= ($generated@@389 ($generated@@177 $generated@@390)) $generated@@390) - :pattern ( ($generated@@177 $generated@@390)) +(assert (forall (($generated@@277 T@U) ($generated@@278 T@U) ($generated@@279 T@T) ) (! (= ($generated@@47 ($generated@@165 $generated@@279 $generated@@277) $generated@@278) ($generated@@98 $generated@@279 $generated@@277 $generated@@278)) + :pattern ( ($generated@@47 ($generated@@165 $generated@@279 $generated@@277) $generated@@278)) ))) -(assert (forall (($generated@@391 T@U) ) (! (= ($generated@@39 ($generated@@177 $generated@@391)) $generated@@1) - :pattern ( ($generated@@177 $generated@@391)) +(assert (forall (($generated@@280 T@U) ($generated@@281 T@U) ($generated@@282 T@U) ($generated@@283 T@U) ($generated@@284 T@U) ($generated@@285 T@U) ($generated@@286 T@U) ) (! (=> ($generated@@27 ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 $generated@@23 $generated@@284 $generated@@282 $generated@@286)) ($generated@@233 $generated@@280 $generated@@281 $generated@@282 ($generated@@216 $generated@@283 $generated@@284 $generated@@285) $generated@@286)) + :pattern ( ($generated@@233 $generated@@280 $generated@@281 $generated@@282 ($generated@@216 $generated@@283 $generated@@284 $generated@@285) $generated@@286)) ))) -(assert (forall (($generated@@392 T@U) ($generated@@393 T@T) ) (! (= ($generated@@123 $generated@@393 ($generated@@197 $generated@@393 $generated@@392)) $generated@@392) - :pattern ( ($generated@@197 $generated@@393 $generated@@392)) +(assert (forall (($generated@@288 T@U) ($generated@@289 T@U) ) (! (= ($generated@@287 ($generated@@106 $generated@@288 $generated@@289)) $generated@@288) + :pattern ( ($generated@@106 $generated@@288 $generated@@289)) ))) -(assert (forall (($generated@@394 T@U) ($generated@@395 T@U) ($generated@@396 T@U) ($generated@@397 T@U) ($generated@@398 T@U) ($generated@@399 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@396 $generated@@397) (and ($generated@@140 $generated@@396) ($generated@@140 $generated@@397))) (and ($generated@@47 $generated@@45 $generated@@399 $generated@@394) ($generated@@142 $generated@@155 $generated@@398 ($generated@@156 $generated@@394 $generated@@395)))) (forall (($generated@@400 T@U) ($generated@@401 T@U) ($generated@@402 T@T) ) (=> (and (or (not (= $generated@@400 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@394 $generated@@395 $generated@@396 $generated@@398 $generated@@399) ($generated@@197 $generated@@43 $generated@@400)))) (= ($generated@@123 $generated@@402 ($generated@@53 $generated@@402 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@396 $generated@@400) $generated@@401)) ($generated@@123 $generated@@402 ($generated@@53 $generated@@402 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@397 $generated@@400) $generated@@401)))))) (= ($generated@@257 $generated@@394 $generated@@395 $generated@@396 $generated@@398 $generated@@399) ($generated@@257 $generated@@394 $generated@@395 $generated@@397 $generated@@398 $generated@@399))) - :pattern ( ($generated@@122 $generated@@396 $generated@@397) ($generated@@257 $generated@@394 $generated@@395 $generated@@397 $generated@@398 $generated@@399)) +(assert (forall (($generated@@291 T@U) ($generated@@292 T@U) ) (! (= ($generated@@290 ($generated@@106 $generated@@291 $generated@@292)) $generated@@292) + :pattern ( ($generated@@106 $generated@@291 $generated@@292)) ))) -(assert (forall (($generated@@403 T@U) ($generated@@404 T@U) ($generated@@405 T@U) ($generated@@406 T@U) ($generated@@407 T@U) ($generated@@408 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@405 $generated@@406) (and ($generated@@140 $generated@@405) ($generated@@140 $generated@@406))) (and ($generated@@47 $generated@@45 $generated@@408 $generated@@403) ($generated@@142 $generated@@155 $generated@@407 ($generated@@156 $generated@@403 $generated@@404)))) (forall (($generated@@409 T@U) ($generated@@410 T@U) ($generated@@411 T@T) ) (=> (and (or (not (= $generated@@409 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@403 $generated@@404 $generated@@406 $generated@@407 $generated@@408) ($generated@@197 $generated@@43 $generated@@409)))) (= ($generated@@123 $generated@@411 ($generated@@53 $generated@@411 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@405 $generated@@409) $generated@@410)) ($generated@@123 $generated@@411 ($generated@@53 $generated@@411 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@406 $generated@@409) $generated@@410)))))) (= ($generated@@257 $generated@@403 $generated@@404 $generated@@405 $generated@@407 $generated@@408) ($generated@@257 $generated@@403 $generated@@404 $generated@@406 $generated@@407 $generated@@408))) - :pattern ( ($generated@@122 $generated@@405 $generated@@406) ($generated@@257 $generated@@403 $generated@@404 $generated@@406 $generated@@407 $generated@@408)) +(assert (forall (($generated@@294 T@U) ($generated@@295 T@U) ) (! (= ($generated@@293 ($generated@@205 $generated@@294 $generated@@295)) $generated@@294) + :pattern ( ($generated@@205 $generated@@294 $generated@@295)) ))) -(assert (forall (($generated@@412 T@U) ($generated@@413 T@U) ($generated@@414 T@U) ) (! (= ($generated@@142 $generated@@155 $generated@@414 ($generated@@236 $generated@@412 $generated@@413)) (and ($generated@@142 $generated@@155 $generated@@414 ($generated@@231 $generated@@412 $generated@@413)) (forall (($generated@@415 T@U) ) (=> ($generated@@47 $generated@@45 $generated@@415 $generated@@412) ($generated@@257 $generated@@412 $generated@@413 $generated@@186 $generated@@414 $generated@@415))))) - :pattern ( ($generated@@142 $generated@@155 $generated@@414 ($generated@@236 $generated@@412 $generated@@413))) +(assert (forall (($generated@@297 T@U) ($generated@@298 T@U) ) (! (= ($generated@@296 ($generated@@205 $generated@@297 $generated@@298)) $generated@@298) + :pattern ( ($generated@@205 $generated@@297 $generated@@298)) ))) -(assert (forall (($generated@@416 T@U) ($generated@@417 T@U) ($generated@@418 T@U) ) (! (= ($generated@@142 $generated@@155 $generated@@418 ($generated@@231 $generated@@416 $generated@@417)) (and ($generated@@142 $generated@@155 $generated@@418 ($generated@@156 $generated@@416 $generated@@417)) (forall (($generated@@419 T@U) ) (=> ($generated@@47 $generated@@45 $generated@@419 $generated@@416) ($generated@@187 $generated@@45 ($generated@@185 $generated@@416 $generated@@417 $generated@@186 $generated@@418 $generated@@419) ($generated@@188 $generated@@45)))))) - :pattern ( ($generated@@142 $generated@@155 $generated@@418 ($generated@@231 $generated@@416 $generated@@417))) +(assert (forall (($generated@@300 T@U) ($generated@@301 T@U) ) (! (= ($generated@@299 ($generated@@210 $generated@@300 $generated@@301)) $generated@@300) + :pattern ( ($generated@@210 $generated@@300 $generated@@301)) ))) -(assert (forall (($generated@@421 T@U) ($generated@@422 T@U) ($generated@@423 T@T) ) (! (= ($generated@@204 $generated@@423 $generated@@421 ($generated@@420 $generated@@422)) ($generated@@204 $generated@@423 $generated@@421 $generated@@422)) - :pattern ( ($generated@@204 $generated@@423 $generated@@421 ($generated@@420 $generated@@422))) +(assert (forall (($generated@@303 T@U) ($generated@@304 T@U) ) (! (= ($generated@@302 ($generated@@210 $generated@@303 $generated@@304)) $generated@@304) + :pattern ( ($generated@@210 $generated@@303 $generated@@304)) ))) -(assert (forall (($generated@@424 T@U) ($generated@@425 T@U) ($generated@@426 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@426 ($generated@@156 $generated@@424 $generated@@425)) (and (= ($generated@@197 $generated@@155 ($generated@@123 $generated@@155 $generated@@426)) $generated@@426) ($generated@@142 $generated@@155 ($generated@@123 $generated@@155 $generated@@426) ($generated@@156 $generated@@424 $generated@@425)))) - :pattern ( ($generated@@47 $generated@@45 $generated@@426 ($generated@@156 $generated@@424 $generated@@425))) +(assert (forall (($generated@@305 T@U) ) (! ($generated@@98 $generated@@43 $generated@@305 $generated@@125) + :pattern ( ($generated@@98 $generated@@43 $generated@@305 $generated@@125)) ))) -(assert (forall (($generated@@427 T@U) ($generated@@428 T@U) ($generated@@429 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@429 ($generated@@231 $generated@@427 $generated@@428)) (and (= ($generated@@197 $generated@@155 ($generated@@123 $generated@@155 $generated@@429)) $generated@@429) ($generated@@142 $generated@@155 ($generated@@123 $generated@@155 $generated@@429) ($generated@@231 $generated@@427 $generated@@428)))) - :pattern ( ($generated@@47 $generated@@45 $generated@@429 ($generated@@231 $generated@@427 $generated@@428))) +(assert (forall (($generated@@307 T@U) ) (! (= ($generated@@306 ($generated@@137 $generated@@307)) $generated@@307) + :pattern ( ($generated@@137 $generated@@307)) ))) -(assert (forall (($generated@@430 T@U) ($generated@@431 T@U) ($generated@@432 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@432 ($generated@@236 $generated@@430 $generated@@431)) (and (= ($generated@@197 $generated@@155 ($generated@@123 $generated@@155 $generated@@432)) $generated@@432) ($generated@@142 $generated@@155 ($generated@@123 $generated@@155 $generated@@432) ($generated@@236 $generated@@430 $generated@@431)))) - :pattern ( ($generated@@47 $generated@@45 $generated@@432 ($generated@@236 $generated@@430 $generated@@431))) +(assert (forall (($generated@@308 T@U) ) (! (= ($generated@@39 ($generated@@137 $generated@@308)) $generated@@1) + :pattern ( ($generated@@137 $generated@@308)) ))) -(assert (forall (($generated@@433 T@U) ($generated@@434 T@T) ) (! (not ($generated@@27 ($generated@@49 $generated@@434 $generated@@23 ($generated@@188 $generated@@434) $generated@@433))) - :pattern ( ($generated@@49 $generated@@434 $generated@@23 ($generated@@188 $generated@@434) $generated@@433)) +(assert (forall (($generated@@309 T@U) ($generated@@310 T@T) ) (! (= ($generated@@126 $generated@@310 ($generated@@165 $generated@@310 $generated@@309)) $generated@@309) + :pattern ( ($generated@@165 $generated@@310 $generated@@309)) ))) -(assert (forall (($generated@@436 T@U) ($generated@@437 T@U) ) (! (and (= ($generated@@39 ($generated@@156 $generated@@436 $generated@@437)) $generated@@5) (= ($generated@@435 ($generated@@156 $generated@@436 $generated@@437)) $generated@@15)) - :pattern ( ($generated@@156 $generated@@436 $generated@@437)) +(assert (forall (($generated@@311 T@U) ($generated@@312 T@U) ) (! (=> (and ($generated@@148 $generated@@311) (and (or (not (= $generated@@312 $generated@@100)) (not true)) (= ($generated@@101 $generated@@312) $generated@@103))) ($generated@@98 $generated@@24 ($generated@@126 $generated@@24 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@311 $generated@@312) $generated@@124)) $generated)) + :pattern ( ($generated@@126 $generated@@24 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@311 $generated@@312) $generated@@124))) ))) -(assert (forall (($generated@@438 T@U) ($generated@@439 T@U) ) (! (and (= ($generated@@39 ($generated@@231 $generated@@438 $generated@@439)) $generated@@6) (= ($generated@@435 ($generated@@231 $generated@@438 $generated@@439)) $generated@@16)) - :pattern ( ($generated@@231 $generated@@438 $generated@@439)) +(assert (forall (($generated@@313 T@U) ($generated@@314 T@U) ($generated@@315 T@U) ) (! (= ($generated@@98 $generated@@105 $generated@@315 ($generated@@210 $generated@@313 $generated@@314)) (and ($generated@@98 $generated@@105 $generated@@315 ($generated@@205 $generated@@313 $generated@@314)) (forall (($generated@@316 T@U) ) (=> ($generated@@47 $generated@@316 $generated@@313) ($generated@@233 $generated@@313 $generated@@314 $generated@@147 $generated@@315 $generated@@316))))) + :pattern ( ($generated@@98 $generated@@105 $generated@@315 ($generated@@210 $generated@@313 $generated@@314))) ))) -(assert (forall (($generated@@440 T@U) ($generated@@441 T@U) ) (! (and (= ($generated@@39 ($generated@@236 $generated@@440 $generated@@441)) $generated@@7) (= ($generated@@435 ($generated@@236 $generated@@440 $generated@@441)) $generated@@17)) - :pattern ( ($generated@@236 $generated@@440 $generated@@441)) +(assert (forall (($generated@@317 T@U) ($generated@@318 T@U) ($generated@@319 T@U) ) (! (= ($generated@@98 $generated@@105 $generated@@319 ($generated@@205 $generated@@317 $generated@@318)) (and ($generated@@98 $generated@@105 $generated@@319 ($generated@@106 $generated@@317 $generated@@318)) (forall (($generated@@320 T@U) ) (=> ($generated@@47 $generated@@320 $generated@@317) ($generated@@149 ($generated@@146 $generated@@317 $generated@@318 $generated@@147 $generated@@319 $generated@@320) $generated@@150))))) + :pattern ( ($generated@@98 $generated@@105 $generated@@319 ($generated@@205 $generated@@317 $generated@@318))) ))) -(assert (forall (($generated@@442 T@U) ($generated@@443 T@U) ($generated@@444 T@U) ($generated@@445 T@U) ($generated@@446 T@U) ) (! (=> (and (and ($generated@@140 $generated@@444) (and ($generated@@47 $generated@@45 $generated@@446 $generated@@442) ($generated@@142 $generated@@155 $generated@@445 ($generated@@156 $generated@@442 $generated@@443)))) ($generated@@187 $generated@@45 ($generated@@185 $generated@@442 $generated@@443 $generated@@186 $generated@@445 $generated@@446) ($generated@@188 $generated@@45))) (= ($generated@@257 $generated@@442 $generated@@443 $generated@@186 $generated@@445 $generated@@446) ($generated@@257 $generated@@442 $generated@@443 $generated@@444 $generated@@445 $generated@@446))) - :pattern ( ($generated@@257 $generated@@442 $generated@@443 $generated@@186 $generated@@445 $generated@@446) ($generated@@140 $generated@@444)) - :pattern ( ($generated@@257 $generated@@442 $generated@@443 $generated@@444 $generated@@445 $generated@@446)) +(assert (forall (($generated@@322 T@U) ($generated@@323 T@U) ($generated@@324 T@T) ) (! (= ($generated@@179 $generated@@324 $generated@@322 ($generated@@321 $generated@@323)) ($generated@@179 $generated@@324 $generated@@322 $generated@@323)) + :pattern ( ($generated@@179 $generated@@324 $generated@@322 ($generated@@321 $generated@@323))) ))) -(assert (forall (($generated@@447 T@U) ($generated@@448 T@U) ($generated@@449 T@U) ($generated@@450 T@U) ($generated@@451 T@U) ($generated@@452 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@449 $generated@@450) (and ($generated@@140 $generated@@449) ($generated@@140 $generated@@450))) (and ($generated@@47 $generated@@45 $generated@@452 $generated@@447) ($generated@@142 $generated@@155 $generated@@451 ($generated@@156 $generated@@447 $generated@@448)))) (forall (($generated@@453 T@U) ($generated@@454 T@U) ($generated@@455 T@T) ) (=> (and (or (not (= $generated@@453 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@447 $generated@@448 $generated@@449 $generated@@451 $generated@@452) ($generated@@197 $generated@@43 $generated@@453)))) (= ($generated@@123 $generated@@455 ($generated@@53 $generated@@455 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@449 $generated@@453) $generated@@454)) ($generated@@123 $generated@@455 ($generated@@53 $generated@@455 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@450 $generated@@453) $generated@@454)))))) (= ($generated@@185 $generated@@447 $generated@@448 $generated@@449 $generated@@451 $generated@@452) ($generated@@185 $generated@@447 $generated@@448 $generated@@450 $generated@@451 $generated@@452))) - :pattern ( ($generated@@122 $generated@@449 $generated@@450) ($generated@@185 $generated@@447 $generated@@448 $generated@@450 $generated@@451 $generated@@452)) +(assert (forall (($generated@@325 T@U) ($generated@@326 T@U) ($generated@@327 T@U) ) (! (=> ($generated@@47 $generated@@327 ($generated@@106 $generated@@325 $generated@@326)) (and (= ($generated@@165 $generated@@105 ($generated@@126 $generated@@105 $generated@@327)) $generated@@327) ($generated@@98 $generated@@105 ($generated@@126 $generated@@105 $generated@@327) ($generated@@106 $generated@@325 $generated@@326)))) + :pattern ( ($generated@@47 $generated@@327 ($generated@@106 $generated@@325 $generated@@326))) ))) -(assert (forall (($generated@@456 T@U) ($generated@@457 T@U) ($generated@@458 T@U) ($generated@@459 T@U) ($generated@@460 T@U) ($generated@@461 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@458 $generated@@459) (and ($generated@@140 $generated@@458) ($generated@@140 $generated@@459))) (and ($generated@@47 $generated@@45 $generated@@461 $generated@@456) ($generated@@142 $generated@@155 $generated@@460 ($generated@@156 $generated@@456 $generated@@457)))) (forall (($generated@@462 T@U) ($generated@@463 T@U) ($generated@@464 T@T) ) (=> (and (or (not (= $generated@@462 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@456 $generated@@457 $generated@@459 $generated@@460 $generated@@461) ($generated@@197 $generated@@43 $generated@@462)))) (= ($generated@@123 $generated@@464 ($generated@@53 $generated@@464 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@458 $generated@@462) $generated@@463)) ($generated@@123 $generated@@464 ($generated@@53 $generated@@464 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@459 $generated@@462) $generated@@463)))))) (= ($generated@@185 $generated@@456 $generated@@457 $generated@@458 $generated@@460 $generated@@461) ($generated@@185 $generated@@456 $generated@@457 $generated@@459 $generated@@460 $generated@@461))) - :pattern ( ($generated@@122 $generated@@458 $generated@@459) ($generated@@185 $generated@@456 $generated@@457 $generated@@459 $generated@@460 $generated@@461)) +(assert (forall (($generated@@328 T@U) ($generated@@329 T@U) ($generated@@330 T@U) ) (! (=> ($generated@@47 $generated@@330 ($generated@@205 $generated@@328 $generated@@329)) (and (= ($generated@@165 $generated@@105 ($generated@@126 $generated@@105 $generated@@330)) $generated@@330) ($generated@@98 $generated@@105 ($generated@@126 $generated@@105 $generated@@330) ($generated@@205 $generated@@328 $generated@@329)))) + :pattern ( ($generated@@47 $generated@@330 ($generated@@205 $generated@@328 $generated@@329))) ))) -(assert (forall (($generated@@465 T@U) ($generated@@466 T@U) ($generated@@467 T@U) ($generated@@468 T@U) ($generated@@469 T@U) ($generated@@470 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@467 $generated@@468) (and ($generated@@140 $generated@@467) ($generated@@140 $generated@@468))) (and ($generated@@47 $generated@@45 $generated@@470 $generated@@465) ($generated@@142 $generated@@155 $generated@@469 ($generated@@156 $generated@@465 $generated@@466)))) (forall (($generated@@471 T@U) ($generated@@472 T@U) ($generated@@473 T@T) ) (=> (and (or (not (= $generated@@471 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@465 $generated@@466 $generated@@467 $generated@@469 $generated@@470) ($generated@@197 $generated@@43 $generated@@471)))) (= ($generated@@123 $generated@@473 ($generated@@53 $generated@@473 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@467 $generated@@471) $generated@@472)) ($generated@@123 $generated@@473 ($generated@@53 $generated@@473 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@468 $generated@@471) $generated@@472)))))) (= ($generated@@241 $generated@@465 $generated@@466 $generated@@467 $generated@@469 $generated@@470) ($generated@@241 $generated@@465 $generated@@466 $generated@@468 $generated@@469 $generated@@470))) - :pattern ( ($generated@@122 $generated@@467 $generated@@468) ($generated@@241 $generated@@465 $generated@@466 $generated@@468 $generated@@469 $generated@@470)) +(assert (forall (($generated@@331 T@U) ($generated@@332 T@U) ($generated@@333 T@U) ) (! (=> ($generated@@47 $generated@@333 ($generated@@210 $generated@@331 $generated@@332)) (and (= ($generated@@165 $generated@@105 ($generated@@126 $generated@@105 $generated@@333)) $generated@@333) ($generated@@98 $generated@@105 ($generated@@126 $generated@@105 $generated@@333) ($generated@@210 $generated@@331 $generated@@332)))) + :pattern ( ($generated@@47 $generated@@333 ($generated@@210 $generated@@331 $generated@@332))) ))) -(assert (forall (($generated@@474 T@U) ($generated@@475 T@U) ($generated@@476 T@U) ($generated@@477 T@U) ($generated@@478 T@U) ($generated@@479 T@U) ) (! (=> (and (and (and ($generated@@122 $generated@@476 $generated@@477) (and ($generated@@140 $generated@@476) ($generated@@140 $generated@@477))) (and ($generated@@47 $generated@@45 $generated@@479 $generated@@474) ($generated@@142 $generated@@155 $generated@@478 ($generated@@156 $generated@@474 $generated@@475)))) (forall (($generated@@480 T@U) ($generated@@481 T@U) ($generated@@482 T@T) ) (=> (and (or (not (= $generated@@480 $generated@@129)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@185 $generated@@474 $generated@@475 $generated@@477 $generated@@478 $generated@@479) ($generated@@197 $generated@@43 $generated@@480)))) (= ($generated@@123 $generated@@482 ($generated@@53 $generated@@482 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@476 $generated@@480) $generated@@481)) ($generated@@123 $generated@@482 ($generated@@53 $generated@@482 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@477 $generated@@480) $generated@@481)))))) (= ($generated@@241 $generated@@474 $generated@@475 $generated@@476 $generated@@478 $generated@@479) ($generated@@241 $generated@@474 $generated@@475 $generated@@477 $generated@@478 $generated@@479))) - :pattern ( ($generated@@122 $generated@@476 $generated@@477) ($generated@@241 $generated@@474 $generated@@475 $generated@@477 $generated@@478 $generated@@479)) +(assert (forall (($generated@@334 T@U) ) (! (not ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 $generated@@150 $generated@@334))) + :pattern ( ($generated@@49 $generated@@45 $generated@@23 $generated@@150 $generated@@334)) ))) -(assert (forall (($generated@@483 T@U) ($generated@@484 T@U) ) (! (=> ($generated@@47 $generated@@45 $generated@@483 ($generated@@177 $generated@@484)) (and (= ($generated@@197 ($generated@@42 $generated@@45 $generated@@23) ($generated@@123 ($generated@@42 $generated@@45 $generated@@23) $generated@@483)) $generated@@483) ($generated@@142 ($generated@@42 $generated@@45 $generated@@23) ($generated@@123 ($generated@@42 $generated@@45 $generated@@23) $generated@@483) ($generated@@177 $generated@@484)))) - :pattern ( ($generated@@47 $generated@@45 $generated@@483 ($generated@@177 $generated@@484))) +(assert (forall (($generated@@336 T@U) ($generated@@337 T@U) ($generated@@338 T@U) ($generated@@339 Bool) ($generated@@340 T@U) ($generated@@341 T@U) ) (! (= ($generated@@27 ($generated@@41 $generated@@43 $generated@@44 $generated@@23 ($generated@@335 $generated@@336 $generated@@337 $generated@@338 $generated@@339) $generated@@340 $generated@@341)) (=> (and (or (not (= $generated@@340 $generated@@336)) (not true)) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@337 $generated@@340) $generated@@338)))) $generated@@339)) + :pattern ( ($generated@@41 $generated@@43 $generated@@44 $generated@@23 ($generated@@335 $generated@@336 $generated@@337 $generated@@338 $generated@@339) $generated@@340 $generated@@341)) ))) -(assert (= ($generated@@39 $generated@@128) $generated@@4)) -(assert (= ($generated@@435 $generated@@128) $generated@@14)) -(assert (= ($generated@@39 $generated@@143) $generated@@8)) -(assert (= ($generated@@435 $generated@@143) $generated@@18)) -(assert (= ($generated@@39 $generated@@132) $generated@@10)) -(assert (= ($generated@@435 $generated@@132) $generated@@18)) -(assert (= ($generated@@39 $generated@@166) $generated@@11)) -(assert (= ($generated@@435 $generated@@166) $generated@@19)) -(assert (= ($generated@@39 $generated@@135) $generated@@13)) -(assert (= ($generated@@435 $generated@@135) $generated@@19)) -(assert (forall (($generated@@485 T@U) ) (! ($generated@@142 ($generated@@42 $generated@@45 $generated@@23) ($generated@@201 $generated@@485) ($generated@@177 $generated@@128)) - :pattern ( ($generated@@201 $generated@@485)) +(assert (forall (($generated@@343 T@U) ($generated@@344 T@U) ) (! (and (= ($generated@@39 ($generated@@106 $generated@@343 $generated@@344)) $generated@@5) (= ($generated@@342 ($generated@@106 $generated@@343 $generated@@344)) $generated@@15)) + :pattern ( ($generated@@106 $generated@@343 $generated@@344)) ))) -(assert (forall (($generated@@486 Int) ) (! (= ($generated@@197 $generated@@24 ($generated@@28 ($generated@@173 $generated@@486))) ($generated@@182 $generated@@45 ($generated@@197 $generated@@24 ($generated@@28 $generated@@486)))) - :pattern ( ($generated@@197 $generated@@24 ($generated@@28 ($generated@@173 $generated@@486)))) +(assert (forall (($generated@@345 T@U) ($generated@@346 T@U) ) (! (and (= ($generated@@39 ($generated@@205 $generated@@345 $generated@@346)) $generated@@6) (= ($generated@@342 ($generated@@205 $generated@@345 $generated@@346)) $generated@@16)) + :pattern ( ($generated@@205 $generated@@345 $generated@@346)) ))) -(assert (forall (($generated@@487 T@U) ($generated@@488 T@T) ) (! (= ($generated@@197 $generated@@488 ($generated@@182 $generated@@488 $generated@@487)) ($generated@@182 $generated@@45 ($generated@@197 $generated@@488 $generated@@487))) - :pattern ( ($generated@@197 $generated@@488 ($generated@@182 $generated@@488 $generated@@487))) +(assert (forall (($generated@@347 T@U) ($generated@@348 T@U) ) (! (and (= ($generated@@39 ($generated@@210 $generated@@347 $generated@@348)) $generated@@7) (= ($generated@@342 ($generated@@210 $generated@@347 $generated@@348)) $generated@@17)) + :pattern ( ($generated@@210 $generated@@347 $generated@@348)) ))) -(assert (=> (<= 1 $generated@@172) (forall (($generated@@489 T@U) ($generated@@490 Int) ($generated@@491 T@U) ) (! (=> (or ($generated@@141 $generated@@489 $generated@@490 $generated@@491) (and (< 1 $generated@@172) (and ($generated@@140 $generated@@489) ($generated@@142 $generated@@43 $generated@@491 $generated@@143)))) (= ($generated@@139 $generated@@489 $generated@@490 $generated@@491) ($generated@@173 3))) - :pattern ( ($generated@@139 $generated@@489 $generated@@490 $generated@@491) ($generated@@140 $generated@@489)) +(assert (forall (($generated@@349 T@U) ($generated@@350 T@U) ($generated@@351 T@U) ($generated@@352 T@U) ($generated@@353 T@U) ) (! (=> (and (and ($generated@@148 $generated@@351) (and ($generated@@47 $generated@@353 $generated@@349) ($generated@@98 $generated@@105 $generated@@352 ($generated@@106 $generated@@349 $generated@@350)))) ($generated@@149 ($generated@@146 $generated@@349 $generated@@350 $generated@@147 $generated@@352 $generated@@353) $generated@@150)) (= ($generated@@233 $generated@@349 $generated@@350 $generated@@147 $generated@@352 $generated@@353) ($generated@@233 $generated@@349 $generated@@350 $generated@@351 $generated@@352 $generated@@353))) + :pattern ( ($generated@@233 $generated@@349 $generated@@350 $generated@@147 $generated@@352 $generated@@353) ($generated@@148 $generated@@351)) + :pattern ( ($generated@@233 $generated@@349 $generated@@350 $generated@@351 $generated@@352 $generated@@353)) +))) +(assert (forall (($generated@@354 T@U) ($generated@@355 T@U) ) (! (=> ($generated@@47 $generated@@354 ($generated@@137 $generated@@355)) (and (= ($generated@@165 ($generated@@42 $generated@@45 $generated@@23) ($generated@@126 ($generated@@42 $generated@@45 $generated@@23) $generated@@354)) $generated@@354) ($generated@@98 ($generated@@42 $generated@@45 $generated@@23) ($generated@@126 ($generated@@42 $generated@@45 $generated@@23) $generated@@354) ($generated@@137 $generated@@355)))) + :pattern ( ($generated@@47 $generated@@354 ($generated@@137 $generated@@355))) +))) +(assert (= ($generated@@39 $generated@@125) $generated@@4)) +(assert (= ($generated@@342 $generated@@125) $generated@@14)) +(assert (= ($generated@@39 $generated@@115) $generated@@8)) +(assert (= ($generated@@342 $generated@@115) $generated@@18)) +(assert (= ($generated@@39 $generated@@99) $generated@@10)) +(assert (= ($generated@@342 $generated@@99) $generated@@18)) +(assert (= ($generated@@39 $generated@@118) $generated@@11)) +(assert (= ($generated@@342 $generated@@118) $generated@@19)) +(assert (= ($generated@@39 $generated@@103) $generated@@13)) +(assert (= ($generated@@342 $generated@@103) $generated@@19)) +(assert (forall (($generated@@356 T@U) ) (! ($generated@@98 ($generated@@42 $generated@@45 $generated@@23) ($generated@@176 $generated@@356) ($generated@@137 $generated@@125)) + :pattern ( ($generated@@176 $generated@@356)) +))) +(assert (forall (($generated@@357 T@U) ($generated@@358 T@U) ($generated@@359 T@U) ($generated@@360 T@U) ($generated@@361 T@U) ($generated@@362 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@359 $generated@@360) (and ($generated@@148 $generated@@359) ($generated@@148 $generated@@360))) (and ($generated@@47 $generated@@362 $generated@@357) ($generated@@98 $generated@@105 $generated@@361 ($generated@@106 $generated@@357 $generated@@358)))) (forall (($generated@@363 T@U) ($generated@@364 T@U) ) (=> (and (or (not (= $generated@@363 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@357 $generated@@358 $generated@@359 $generated@@361 $generated@@362) ($generated@@165 $generated@@43 $generated@@363)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@359 $generated@@363) $generated@@364) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@360 $generated@@363) $generated@@364))))) (= ($generated@@233 $generated@@357 $generated@@358 $generated@@359 $generated@@361 $generated@@362) ($generated@@233 $generated@@357 $generated@@358 $generated@@360 $generated@@361 $generated@@362))) + :pattern ( ($generated@@133 $generated@@359 $generated@@360) ($generated@@233 $generated@@357 $generated@@358 $generated@@360 $generated@@361 $generated@@362)) +))) +(assert (forall (($generated@@365 T@U) ($generated@@366 T@U) ($generated@@367 T@U) ($generated@@368 T@U) ($generated@@369 T@U) ($generated@@370 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@367 $generated@@368) (and ($generated@@148 $generated@@367) ($generated@@148 $generated@@368))) (and ($generated@@47 $generated@@370 $generated@@365) ($generated@@98 $generated@@105 $generated@@369 ($generated@@106 $generated@@365 $generated@@366)))) (forall (($generated@@371 T@U) ($generated@@372 T@U) ) (=> (and (or (not (= $generated@@371 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@365 $generated@@366 $generated@@368 $generated@@369 $generated@@370) ($generated@@165 $generated@@43 $generated@@371)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@367 $generated@@371) $generated@@372) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@368 $generated@@371) $generated@@372))))) (= ($generated@@233 $generated@@365 $generated@@366 $generated@@367 $generated@@369 $generated@@370) ($generated@@233 $generated@@365 $generated@@366 $generated@@368 $generated@@369 $generated@@370))) + :pattern ( ($generated@@133 $generated@@367 $generated@@368) ($generated@@233 $generated@@365 $generated@@366 $generated@@368 $generated@@369 $generated@@370)) +))) +(assert (forall (($generated@@373 Int) ) (! (= ($generated@@165 $generated@@24 ($generated@@28 ($generated@@141 $generated@@373))) ($generated@@143 $generated@@45 ($generated@@165 $generated@@24 ($generated@@28 $generated@@373)))) + :pattern ( ($generated@@165 $generated@@24 ($generated@@28 ($generated@@141 $generated@@373)))) +))) +(assert (forall (($generated@@374 T@U) ($generated@@375 T@T) ) (! (= ($generated@@165 $generated@@375 ($generated@@143 $generated@@375 $generated@@374)) ($generated@@143 $generated@@45 ($generated@@165 $generated@@375 $generated@@374))) + :pattern ( ($generated@@165 $generated@@375 ($generated@@143 $generated@@375 $generated@@374))) +))) +(assert (forall (($generated@@376 T@U) ($generated@@377 T@U) ($generated@@378 T@U) ($generated@@379 T@U) ($generated@@380 T@U) ($generated@@381 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@378 $generated@@379) (and ($generated@@148 $generated@@378) ($generated@@148 $generated@@379))) (and ($generated@@47 $generated@@381 $generated@@376) ($generated@@98 $generated@@105 $generated@@380 ($generated@@106 $generated@@376 $generated@@377)))) (forall (($generated@@382 T@U) ($generated@@383 T@U) ) (=> (and (or (not (= $generated@@382 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@376 $generated@@377 $generated@@378 $generated@@380 $generated@@381) ($generated@@165 $generated@@43 $generated@@382)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@378 $generated@@382) $generated@@383) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@379 $generated@@382) $generated@@383))))) (= ($generated@@146 $generated@@376 $generated@@377 $generated@@378 $generated@@380 $generated@@381) ($generated@@146 $generated@@376 $generated@@377 $generated@@379 $generated@@380 $generated@@381))) + :pattern ( ($generated@@133 $generated@@378 $generated@@379) ($generated@@146 $generated@@376 $generated@@377 $generated@@379 $generated@@380 $generated@@381)) +))) +(assert (forall (($generated@@384 T@U) ($generated@@385 T@U) ($generated@@386 T@U) ($generated@@387 T@U) ($generated@@388 T@U) ($generated@@389 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@386 $generated@@387) (and ($generated@@148 $generated@@386) ($generated@@148 $generated@@387))) (and ($generated@@47 $generated@@389 $generated@@384) ($generated@@98 $generated@@105 $generated@@388 ($generated@@106 $generated@@384 $generated@@385)))) (forall (($generated@@390 T@U) ($generated@@391 T@U) ) (=> (and (or (not (= $generated@@390 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@384 $generated@@385 $generated@@387 $generated@@388 $generated@@389) ($generated@@165 $generated@@43 $generated@@390)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@386 $generated@@390) $generated@@391) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@387 $generated@@390) $generated@@391))))) (= ($generated@@146 $generated@@384 $generated@@385 $generated@@386 $generated@@388 $generated@@389) ($generated@@146 $generated@@384 $generated@@385 $generated@@387 $generated@@388 $generated@@389))) + :pattern ( ($generated@@133 $generated@@386 $generated@@387) ($generated@@146 $generated@@384 $generated@@385 $generated@@387 $generated@@388 $generated@@389)) +))) +(assert (forall (($generated@@392 T@U) ($generated@@393 T@U) ($generated@@394 T@U) ($generated@@395 T@U) ($generated@@396 T@U) ($generated@@397 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@394 $generated@@395) (and ($generated@@148 $generated@@394) ($generated@@148 $generated@@395))) (and ($generated@@47 $generated@@397 $generated@@392) ($generated@@98 $generated@@105 $generated@@396 ($generated@@106 $generated@@392 $generated@@393)))) (forall (($generated@@398 T@U) ($generated@@399 T@U) ) (=> (and (or (not (= $generated@@398 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@392 $generated@@393 $generated@@394 $generated@@396 $generated@@397) ($generated@@165 $generated@@43 $generated@@398)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@394 $generated@@398) $generated@@399) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@395 $generated@@398) $generated@@399))))) (= ($generated@@215 $generated@@392 $generated@@393 $generated@@394 $generated@@396 $generated@@397) ($generated@@215 $generated@@392 $generated@@393 $generated@@395 $generated@@396 $generated@@397))) + :pattern ( ($generated@@133 $generated@@394 $generated@@395) ($generated@@215 $generated@@392 $generated@@393 $generated@@395 $generated@@396 $generated@@397)) +))) +(assert (forall (($generated@@400 T@U) ($generated@@401 T@U) ($generated@@402 T@U) ($generated@@403 T@U) ($generated@@404 T@U) ($generated@@405 T@U) ) (! (=> (and (and (and ($generated@@133 $generated@@402 $generated@@403) (and ($generated@@148 $generated@@402) ($generated@@148 $generated@@403))) (and ($generated@@47 $generated@@405 $generated@@400) ($generated@@98 $generated@@105 $generated@@404 ($generated@@106 $generated@@400 $generated@@401)))) (forall (($generated@@406 T@U) ($generated@@407 T@U) ) (=> (and (or (not (= $generated@@406 $generated@@100)) (not true)) ($generated@@27 ($generated@@49 $generated@@45 $generated@@23 ($generated@@146 $generated@@400 $generated@@401 $generated@@403 $generated@@404 $generated@@405) ($generated@@165 $generated@@43 $generated@@406)))) (= ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@402 $generated@@406) $generated@@407) ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@403 $generated@@406) $generated@@407))))) (= ($generated@@215 $generated@@400 $generated@@401 $generated@@402 $generated@@404 $generated@@405) ($generated@@215 $generated@@400 $generated@@401 $generated@@403 $generated@@404 $generated@@405))) + :pattern ( ($generated@@133 $generated@@402 $generated@@403) ($generated@@215 $generated@@400 $generated@@401 $generated@@403 $generated@@404 $generated@@405)) +))) +(assert (=> (<= 1 $generated@@168) (forall (($generated@@408 T@U) ($generated@@409 Int) ($generated@@410 T@U) ) (! (=> (or ($generated@@158 $generated@@408 $generated@@409 $generated@@410) (and (< 1 $generated@@168) (and ($generated@@148 $generated@@408) ($generated@@98 $generated@@43 $generated@@410 $generated@@115)))) (= ($generated@@157 $generated@@408 $generated@@409 $generated@@410) ($generated@@141 3))) + :pattern ( ($generated@@157 $generated@@408 $generated@@409 $generated@@410) ($generated@@148 $generated@@408)) )))) -(assert (forall (($generated@@492 T@U) ($generated@@493 T@U) ) (! ($generated@@127 $generated@@24 $generated@@493 $generated $generated@@492) - :pattern ( ($generated@@127 $generated@@24 $generated@@493 $generated $generated@@492)) +(assert (forall (($generated@@411 T@U) ($generated@@412 T@U) ) (! ($generated@@114 $generated@@24 $generated@@412 $generated $generated@@411) + :pattern ( ($generated@@114 $generated@@24 $generated@@412 $generated $generated@@411)) ))) -(assert (forall (($generated@@495 T@U) ($generated@@496 T@U) ($generated@@497 T@U) ) (! (= ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) ($generated@@494 $generated@@495) $generated@@496 $generated@@497) $generated@@495) - :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) ($generated@@494 $generated@@495) $generated@@496 $generated@@497)) +(assert (forall (($generated@@414 T@U) ($generated@@415 T@U) ($generated@@416 T@U) ) (! (= ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) ($generated@@413 $generated@@414) $generated@@415 $generated@@416) $generated@@414) + :pattern ( ($generated@@41 ($generated@@42 $generated@@43 ($generated@@42 $generated@@44 $generated@@45)) $generated@@45 ($generated@@42 $generated@@45 $generated@@23) ($generated@@413 $generated@@414) $generated@@415 $generated@@416)) ))) -(assert (forall (($generated@@498 T@U) ) (! ($generated@@142 $generated@@24 $generated@@498 $generated) - :pattern ( ($generated@@142 $generated@@24 $generated@@498 $generated)) +(assert (forall (($generated@@417 T@U) ) (! ($generated@@98 $generated@@24 $generated@@417 $generated) + :pattern ( ($generated@@98 $generated@@24 $generated@@417 $generated)) ))) (push 1) (declare-fun ControlFlow (Int Int) Int) -(declare-fun $generated@@499 () T@U) -(declare-fun $generated@@500 () T@U) -(declare-fun $generated@@501 () Bool) -(declare-fun $generated@@502 () Int) -(declare-fun $generated@@503 () T@U) -(declare-fun $generated@@504 () T@U) -(declare-fun $generated@@505 () T@U) -(declare-fun $generated@@506 () T@U) -(declare-fun $generated@@507 () T@U) -(declare-fun $generated@@508 () T@U) -(declare-fun $generated@@509 () Int) -(declare-fun $generated@@510 () Bool) -(declare-fun $generated@@511 () T@U) -(declare-fun $generated@@512 () T@U) -(declare-fun $generated@@513 () Bool) -(declare-fun $generated@@514 () T@U) +(declare-fun $generated@@418 () T@U) +(declare-fun $generated@@419 () T@U) +(declare-fun $generated@@420 () Bool) +(declare-fun $generated@@421 () Int) +(declare-fun $generated@@422 () T@U) +(declare-fun $generated@@423 () T@U) +(declare-fun $generated@@424 () T@U) +(declare-fun $generated@@425 () T@U) +(declare-fun $generated@@426 () T@U) +(declare-fun $generated@@427 () T@U) +(declare-fun $generated@@428 () Int) +(declare-fun $generated@@429 () Bool) +(declare-fun $generated@@430 () T@U) +(declare-fun $generated@@431 () T@U) +(declare-fun $generated@@432 () Bool) +(declare-fun $generated@@433 () T@U) (set-option :timeout 0) (set-option :rlimit 0) (set-option :auto_config false) @@ -1043,18 +1016,18 @@ $generated@@226)))))) (set-option :pp.bv_literals false) (set-option :smt.arith.solver 2) (assert (not - (=> (= (ControlFlow 0 0) 9) (let (($generated@@515 true)) -(let (($generated@@516 true)) -(let (($generated@@517 (=> (and ($generated@@140 $generated@@499) (or (= $generated@@500 $generated@@499) ($generated@@122 $generated@@500 $generated@@499))) (and (=> (= (ControlFlow 0 7) 5) $generated@@516) (=> (= (ControlFlow 0 7) 6) $generated@@515))))) -(let (($generated@@518 (=> (= (ControlFlow 0 2) (- 0 1)) (= $generated@@501 (= $generated@@502 ($generated@@173 2)))))) -(let (($generated@@519 (=> (= $generated@@503 ($generated@@182 $generated@@155 ($generated@@204 $generated@@155 ($generated@@272 ($generated@@242 ($generated@@196 1) ($generated@@46 $generated) ($generated@@494 ($generated@@201 ($generated@@269 false))))) ($generated@@420 $generated@@504)))) (=> (and (and (or (not (= $generated@@505 $generated@@129)) (not true)) (and ($generated@@142 $generated@@43 $generated@@505 $generated@@143) ($generated@@127 $generated@@43 $generated@@505 $generated@@143 $generated@@506))) (and ($generated@@140 $generated@@507) ($generated@@138 $generated@@507))) (=> (and (and (and (or (not (= $generated@@508 $generated@@129)) (not true)) (and ($generated@@142 $generated@@43 $generated@@508 $generated@@143) ($generated@@127 $generated@@43 $generated@@508 $generated@@143 $generated@@507))) (not ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@500 $generated@@508) $generated@@2))))) (and (forall (($generated@@520 T@U) ) (! (=> (and (or (not (= $generated@@520 $generated@@129)) (not true)) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@500 $generated@@520) $generated@@2)))) (= ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@507 $generated@@520) ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@500 $generated@@520))) - :pattern ( ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@507 $generated@@520)) -)) ($generated@@122 $generated@@500 $generated@@507))) (and (=> (= (ControlFlow 0 3) (- 0 4)) true) (=> (and (and (and (= $generated@@509 ($generated@@173 42)) ($generated@@127 $generated@@24 ($generated@@28 $generated@@509) $generated $generated@@507)) (and ($generated@@127 $generated@@43 $generated@@508 $generated@@143 $generated@@507) ($generated@@141 $generated@@507 ($generated@@173 42) $generated@@508))) (and (and ($generated@@141 $generated@@507 ($generated@@173 42) $generated@@508) (= $generated@@510 (= $generated@@502 ($generated@@139 $generated@@507 ($generated@@173 42) $generated@@508)))) (and (= $generated@@501 $generated@@510) (= (ControlFlow 0 3) 2)))) $generated@@518))))))) -(let (($generated@@521 (=> (= $generated@@511 ($generated@@335 $generated@@129 $generated@@506 $generated@@2 false)) (=> (and (and (and ($generated@@140 $generated@@500) ($generated@@138 $generated@@500)) ($generated@@27 ($generated@@182 $generated@@23 ($generated@@26 false)))) (and (forall (($generated@@522 T@U) ) (! (=> (and (or (not (= $generated@@522 $generated@@129)) (not true)) ($generated@@27 ($generated@@123 $generated@@23 ($generated@@53 $generated@@23 $generated@@45 ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@506 $generated@@522) $generated@@2)))) (= ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@500 $generated@@522) ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@506 $generated@@522))) - :pattern ( ($generated@@49 $generated@@43 ($generated@@44 $generated@@45) $generated@@500 $generated@@522)) -)) ($generated@@122 $generated@@506 $generated@@500))) (and (=> (= (ControlFlow 0 8) 7) $generated@@517) (=> (= (ControlFlow 0 8) 3) $generated@@519)))))) -(let (($generated@@523 (=> (and ($generated@@140 $generated@@506) ($generated@@138 $generated@@506)) (=> (and (and ($generated@@142 $generated@@155 $generated@@512 ($generated@@236 $generated $generated)) ($generated@@127 $generated@@155 $generated@@512 ($generated@@236 $generated $generated) $generated@@506)) true) (=> (and (and (and (=> $generated@@513 (and ($generated@@142 $generated@@43 $generated@@514 $generated@@143) ($generated@@127 $generated@@43 $generated@@514 $generated@@143 $generated@@506))) true) (= 2 $generated@@172)) (and (= $generated@@502 ($generated@@173 2)) (= (ControlFlow 0 9) 8))) $generated@@521))))) -$generated@@523)))))))) + (=> (= (ControlFlow 0 0) 9) (let (($generated@@434 true)) +(let (($generated@@435 true)) +(let (($generated@@436 (=> (and ($generated@@148 $generated@@418) (or (= $generated@@419 $generated@@418) ($generated@@133 $generated@@419 $generated@@418))) (and (=> (= (ControlFlow 0 7) 5) $generated@@435) (=> (= (ControlFlow 0 7) 6) $generated@@434))))) +(let (($generated@@437 (=> (= (ControlFlow 0 2) (- 0 1)) (= $generated@@420 (= $generated@@421 ($generated@@141 2)))))) +(let (($generated@@438 (=> (= $generated@@422 ($generated@@143 $generated@@105 ($generated@@179 $generated@@105 ($generated@@242 ($generated@@216 ($generated@@172 1) ($generated@@46 $generated) ($generated@@413 ($generated@@176 ($generated@@239 false))))) ($generated@@321 $generated@@423)))) (=> (and (and (or (not (= $generated@@424 $generated@@100)) (not true)) (and ($generated@@98 $generated@@43 $generated@@424 $generated@@115) ($generated@@114 $generated@@43 $generated@@424 $generated@@115 $generated@@425))) (and ($generated@@148 $generated@@426) ($generated@@156 $generated@@426))) (=> (and (and (and (or (not (= $generated@@427 $generated@@100)) (not true)) (and ($generated@@98 $generated@@43 $generated@@427 $generated@@115) ($generated@@114 $generated@@43 $generated@@427 $generated@@115 $generated@@426))) (not ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@419 $generated@@427) $generated@@2))))) (and (forall (($generated@@439 T@U) ) (! (=> (and (or (not (= $generated@@439 $generated@@100)) (not true)) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@419 $generated@@439) $generated@@2)))) (= ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@426 $generated@@439) ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@419 $generated@@439))) + :pattern ( ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@426 $generated@@439)) +)) ($generated@@133 $generated@@419 $generated@@426))) (and (=> (= (ControlFlow 0 3) (- 0 4)) true) (=> (and (and (and (= $generated@@428 ($generated@@141 42)) ($generated@@114 $generated@@24 ($generated@@28 $generated@@428) $generated $generated@@426)) (and ($generated@@114 $generated@@43 $generated@@427 $generated@@115 $generated@@426) ($generated@@158 $generated@@426 ($generated@@141 42) $generated@@427))) (and (and ($generated@@158 $generated@@426 ($generated@@141 42) $generated@@427) (= $generated@@429 (= $generated@@421 ($generated@@157 $generated@@426 ($generated@@141 42) $generated@@427)))) (and (= $generated@@420 $generated@@429) (= (ControlFlow 0 3) 2)))) $generated@@437))))))) +(let (($generated@@440 (=> (= $generated@@430 ($generated@@335 $generated@@100 $generated@@425 $generated@@2 false)) (=> (and (and (and ($generated@@148 $generated@@419) ($generated@@156 $generated@@419)) ($generated@@27 ($generated@@143 $generated@@23 ($generated@@26 false)))) (and (forall (($generated@@441 T@U) ) (! (=> (and (or (not (= $generated@@441 $generated@@100)) (not true)) ($generated@@27 ($generated@@126 $generated@@23 ($generated@@49 $generated@@44 $generated@@45 ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@425 $generated@@441) $generated@@2)))) (= ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@419 $generated@@441) ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@425 $generated@@441))) + :pattern ( ($generated@@49 $generated@@43 ($generated@@42 $generated@@44 $generated@@45) $generated@@419 $generated@@441)) +)) ($generated@@133 $generated@@425 $generated@@419))) (and (=> (= (ControlFlow 0 8) 7) $generated@@436) (=> (= (ControlFlow 0 8) 3) $generated@@438)))))) +(let (($generated@@442 (=> (and ($generated@@148 $generated@@425) ($generated@@156 $generated@@425)) (=> (and (and ($generated@@98 $generated@@105 $generated@@431 ($generated@@210 $generated $generated)) ($generated@@114 $generated@@105 $generated@@431 ($generated@@210 $generated $generated) $generated@@425)) true) (=> (and (and (and (=> $generated@@432 (and ($generated@@98 $generated@@43 $generated@@433 $generated@@115) ($generated@@114 $generated@@43 $generated@@433 $generated@@115 $generated@@425))) true) (= 2 $generated@@168)) (and (= $generated@@421 ($generated@@141 2)) (= (ControlFlow 0 9) 8))) $generated@@440))))) +$generated@@442)))))))) )) (check-sat) (get-info :rlimit) @@ -1124,7 +1097,7 @@ $generated@@523)))))))) (declare-fun $generated@@37 (T@T T@T T@U T@U) T@U) (declare-fun $generated@@38 () T@T) (declare-fun $generated@@39 (T@U) T@U) -(declare-fun $generated@@40 (T@T T@U T@U) Bool) +(declare-fun $generated@@40 (T@U T@U) Bool) (declare-fun $generated@@41 (T@U) Bool) (declare-fun $generated@@42 (T@T T@T) T@T) (declare-fun $generated@@43 () T@T) @@ -1137,32 +1110,29 @@ $generated@@523)))))))) (declare-fun $generated@@90 (T@U) T@U) (declare-fun $generated@@96 (T@U T@U T@U T@U T@U) T@U) (declare-fun $generated@@97 () T@U) -(declare-fun $generated@@98 (T@T T@U T@U) Bool) -(declare-fun $generated@@99 (T@T) T@U) +(declare-fun $generated@@98 (T@U T@U) Bool) +(declare-fun $generated@@99 () T@U) (declare-fun $generated@@105 (T@U T@U) T@U) (declare-fun $generated@@110 (T@U) T@U) -(declare-fun $generated@@120 (T@T T@U T@U T@U) Bool) -(declare-fun $generated@@121 (T@T T@U) T@U) -(declare-fun $generated@@134 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@140 () T@T) -(declare-fun $generated@@141 () T@U) -(declare-fun $generated@@142 (T@T T@U) T@U) -(declare-fun $generated@@143 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@144 (T@T) T@T) -(declare-fun $generated@@145 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@146 (T@T) T@T) +(declare-fun $generated@@112 (T@T T@U) T@U) +(declare-fun $generated@@113 (T@T T@U) T@U) +(declare-fun $generated@@124 (T@U T@U T@U) Bool) +(declare-fun $generated@@136 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@159 () T@T) +(declare-fun $generated@@160 () T@U) +(declare-fun $generated@@161 () T@T) +(declare-fun $generated@@172 (T@U) T@U) +(declare-fun $generated@@175 (T@U) T@U) +(declare-fun $generated@@178 (T@U) T@U) +(declare-fun $generated@@181 (T@U) T@U) +(declare-fun $generated@@186 (T@U) T@U) +(declare-fun $generated@@189 (T@U) T@U) (declare-fun $generated@@196 (T@U) T@U) -(declare-fun $generated@@199 (T@U) T@U) -(declare-fun $generated@@202 (T@U) T@U) -(declare-fun $generated@@205 (T@U) T@U) -(declare-fun $generated@@210 (T@U) T@U) -(declare-fun $generated@@213 (T@U) T@U) -(declare-fun $generated@@220 (T@T T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@221 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@222 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@267 (T@U) T@U) -(declare-fun $generated@@272 (T@U) Int) -(declare-fun $generated@@291 (T@U) T@U) +(declare-fun $generated@@201 (T@U) Int) +(declare-fun $generated@@219 (T@T T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@220 (T@U T@U T@U Bool) T@U) +(declare-fun $generated@@221 (T@T T@T T@T T@U T@U T@U T@U) T@U) +(declare-fun $generated@@253 (T@U) T@U) (assert (and (and (and (and (and (and (and (and (= ($generated@@10 $generated@@11) 0) (= ($generated@@10 $generated@@12) 1)) (= ($generated@@10 $generated@@13) 2)) (forall (($generated@@20 Bool) ) (! (= ($generated@@15 ($generated@@14 $generated@@20)) $generated@@20) :pattern ( ($generated@@14 $generated@@20)) ))) (forall (($generated@@21 T@U) ) (! (= ($generated@@14 ($generated@@15 $generated@@21)) $generated@@21) @@ -1187,10 +1157,10 @@ $generated@@523)))))))) ))) (forall (($generated@@62 T@T) ($generated@@63 T@T) ) (! (= ($generated@@46 ($generated@@42 $generated@@62 $generated@@63)) $generated@@63) :pattern ( ($generated@@42 $generated@@62 $generated@@63)) ))) (= ($generated@@10 $generated@@43) 6))) -(assert (=> (<= 0 $generated@@26) (forall (($generated@@64 T@U) ($generated@@65 T@U) ($generated@@66 T@U) ($generated@@67 T@U) ) (! (=> (or ($generated@@31 $generated@@64 $generated@@65 ($generated@@28 $generated@@29 $generated@@67)) (and (< 0 $generated@@26) (and ($generated@@30 $generated@@66) (and ($generated@@32 $generated@@29 $generated@@67 ($generated@@33 $generated@@64 $generated@@65)) ($generated@@34 $generated@@29 $generated@@67 ($generated@@33 $generated@@64 $generated@@65) $generated@@66))))) (and (forall (($generated@@68 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@68 $generated@@64) (and ($generated@@41 ($generated@@28 $generated@@29 $generated@@67)) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 ($generated@@28 $generated@@29 $generated@@67))) $generated@@68)) (and ($generated@@41 ($generated@@28 $generated@@29 $generated@@67)) true)))) +(assert (=> (<= 0 $generated@@26) (forall (($generated@@64 T@U) ($generated@@65 T@U) ($generated@@66 T@U) ($generated@@67 T@U) ) (! (=> (or ($generated@@31 $generated@@64 $generated@@65 ($generated@@28 $generated@@29 $generated@@67)) (and (< 0 $generated@@26) (and ($generated@@30 $generated@@66) (and ($generated@@32 $generated@@29 $generated@@67 ($generated@@33 $generated@@64 $generated@@65)) ($generated@@34 $generated@@29 $generated@@67 ($generated@@33 $generated@@64 $generated@@65) $generated@@66))))) (and (forall (($generated@@68 T@U) ) (! (=> ($generated@@40 $generated@@68 $generated@@64) (and ($generated@@41 ($generated@@28 $generated@@29 $generated@@67)) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 ($generated@@28 $generated@@29 $generated@@67))) $generated@@68)) (and ($generated@@41 ($generated@@28 $generated@@29 $generated@@67)) true)))) :pattern ( ($generated@@35 $generated@@64 $generated@@65 $generated@@66 ($generated@@36 $generated@@67) $generated@@68)) :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@67) $generated@@68)) -)) (= ($generated@@27 $generated@@64 $generated@@65 ($generated@@28 $generated@@29 $generated@@67)) (forall (($generated@@69 T@U) ) (! (=> (and ($generated@@40 $generated@@38 $generated@@69 $generated@@64) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 ($generated@@28 $generated@@29 $generated@@67))) $generated@@69))) ($generated@@35 $generated@@64 $generated@@65 $generated@@66 ($generated@@28 $generated@@43 ($generated@@36 ($generated@@28 $generated@@29 $generated@@67))) $generated@@69)) +)) (= ($generated@@27 $generated@@64 $generated@@65 ($generated@@28 $generated@@29 $generated@@67)) (forall (($generated@@69 T@U) ) (! (=> (and ($generated@@40 $generated@@69 $generated@@64) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 ($generated@@28 $generated@@29 $generated@@67))) $generated@@69))) ($generated@@35 $generated@@64 $generated@@65 $generated@@66 ($generated@@28 $generated@@43 ($generated@@36 ($generated@@28 $generated@@29 $generated@@67))) $generated@@69)) :pattern ( ($generated@@35 $generated@@64 $generated@@65 $generated@@66 ($generated@@36 $generated@@67) $generated@@69)) :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@67) $generated@@69)) ))))) @@ -1204,19 +1174,19 @@ $generated@@523)))))))) (assert (forall (($generated@@74 T@U) ($generated@@75 T@U) ($generated@@76 T@U) ) (! (=> ($generated@@32 $generated@@29 $generated@@76 ($generated@@33 $generated@@74 $generated@@75)) ($generated@@41 $generated@@76)) :pattern ( ($generated@@41 $generated@@76) ($generated@@32 $generated@@29 $generated@@76 ($generated@@33 $generated@@74 $generated@@75))) ))) -(assert (forall (($generated@@78 T@U) ($generated@@79 T@U) ($generated@@80 T@U) ($generated@@81 T@U) ($generated@@82 T@U) ) (! (=> (and (and ($generated@@32 $generated@@43 $generated@@78 ($generated@@77 $generated@@79 $generated@@80)) (forall (($generated@@83 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@83 $generated@@81) ($generated@@40 $generated@@38 $generated@@83 $generated@@79)) - :pattern ( ($generated@@40 $generated@@38 $generated@@83 $generated@@81)) - :pattern ( ($generated@@40 $generated@@38 $generated@@83 $generated@@79)) -))) (forall (($generated@@84 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@84 $generated@@80) ($generated@@40 $generated@@38 $generated@@84 $generated@@82)) - :pattern ( ($generated@@40 $generated@@38 $generated@@84 $generated@@80)) - :pattern ( ($generated@@40 $generated@@38 $generated@@84 $generated@@82)) +(assert (forall (($generated@@78 T@U) ($generated@@79 T@U) ($generated@@80 T@U) ($generated@@81 T@U) ($generated@@82 T@U) ) (! (=> (and (and ($generated@@32 $generated@@43 $generated@@78 ($generated@@77 $generated@@79 $generated@@80)) (forall (($generated@@83 T@U) ) (! (=> ($generated@@40 $generated@@83 $generated@@81) ($generated@@40 $generated@@83 $generated@@79)) + :pattern ( ($generated@@40 $generated@@83 $generated@@81)) + :pattern ( ($generated@@40 $generated@@83 $generated@@79)) +))) (forall (($generated@@84 T@U) ) (! (=> ($generated@@40 $generated@@84 $generated@@80) ($generated@@40 $generated@@84 $generated@@82)) + :pattern ( ($generated@@40 $generated@@84 $generated@@80)) + :pattern ( ($generated@@40 $generated@@84 $generated@@82)) ))) ($generated@@32 $generated@@43 $generated@@78 ($generated@@77 $generated@@81 $generated@@82))) :pattern ( ($generated@@32 $generated@@43 $generated@@78 ($generated@@77 $generated@@79 $generated@@80)) ($generated@@32 $generated@@43 $generated@@78 ($generated@@77 $generated@@81 $generated@@82))) ))) (assert (forall (($generated@@86 T@U) ($generated@@87 T@U) ($generated@@88 T@U) ($generated@@89 T@U) ) (! (=> (and ($generated@@30 $generated@@89) (and ($generated@@41 $generated@@86) ($generated@@34 $generated@@29 $generated@@86 ($generated@@33 $generated@@87 $generated@@88) $generated@@89))) ($generated@@34 $generated@@43 ($generated@@36 $generated@@86) ($generated@@85 $generated@@87 $generated@@88) $generated@@89)) :pattern ( ($generated@@34 $generated@@43 ($generated@@36 $generated@@86) ($generated@@85 $generated@@87 $generated@@88) $generated@@89)) ))) -(assert (forall (($generated@@91 T@U) ($generated@@92 T@U) ) (! (= ($generated@@32 ($generated@@42 $generated@@38 $generated@@11) $generated@@91 ($generated@@90 $generated@@92)) (forall (($generated@@93 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@91 $generated@@93)) ($generated@@40 $generated@@38 $generated@@93 $generated@@92)) +(assert (forall (($generated@@91 T@U) ($generated@@92 T@U) ) (! (= ($generated@@32 ($generated@@42 $generated@@38 $generated@@11) $generated@@91 ($generated@@90 $generated@@92)) (forall (($generated@@93 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@91 $generated@@93)) ($generated@@40 $generated@@93 $generated@@92)) :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@91 $generated@@93)) ))) :pattern ( ($generated@@32 ($generated@@42 $generated@@38 $generated@@11) $generated@@91 ($generated@@90 $generated@@92))) @@ -1224,7 +1194,7 @@ $generated@@523)))))))) (assert (forall (($generated@@94 T@U) ($generated@@95 T@T) ) (! (= ($generated@@28 $generated@@95 $generated@@94) $generated@@94) :pattern ( ($generated@@28 $generated@@95 $generated@@94)) ))) -(assert (forall (($generated@@100 T@U) ($generated@@101 T@U) ($generated@@102 T@U) ($generated@@103 T@U) ($generated@@104 T@U) ) (! (=> (and ($generated@@30 $generated@@102) (and ($generated@@40 $generated@@38 $generated@@104 $generated@@100) ($generated@@32 $generated@@43 $generated@@103 ($generated@@77 $generated@@100 $generated@@101)))) (= ($generated@@98 $generated@@38 ($generated@@96 $generated@@100 $generated@@101 $generated@@97 $generated@@103 $generated@@104) ($generated@@99 $generated@@38)) ($generated@@98 $generated@@38 ($generated@@96 $generated@@100 $generated@@101 $generated@@102 $generated@@103 $generated@@104) ($generated@@99 $generated@@38)))) +(assert (forall (($generated@@100 T@U) ($generated@@101 T@U) ($generated@@102 T@U) ($generated@@103 T@U) ($generated@@104 T@U) ) (! (=> (and ($generated@@30 $generated@@102) (and ($generated@@40 $generated@@104 $generated@@100) ($generated@@32 $generated@@43 $generated@@103 ($generated@@77 $generated@@100 $generated@@101)))) (= ($generated@@98 ($generated@@96 $generated@@100 $generated@@101 $generated@@97 $generated@@103 $generated@@104) $generated@@99) ($generated@@98 ($generated@@96 $generated@@100 $generated@@101 $generated@@102 $generated@@103 $generated@@104) $generated@@99))) :pattern ( ($generated@@96 $generated@@100 $generated@@101 $generated@@97 $generated@@103 $generated@@104) ($generated@@30 $generated@@102)) :pattern ( ($generated@@96 $generated@@100 $generated@@101 $generated@@102 $generated@@103 $generated@@104)) ))) @@ -1234,185 +1204,178 @@ $generated@@523)))))))) (assert (forall (($generated@@111 T@U) ) (! (= ($generated@@41 $generated@@111) (= ($generated@@110 $generated@@111) $generated@@5)) :pattern ( ($generated@@41 $generated@@111)) ))) -(assert (forall (($generated@@112 T@U) ) (! (=> ($generated@@41 $generated@@112) (exists (($generated@@113 T@U) ($generated@@114 T@U) ) (= $generated@@112 ($generated@@105 $generated@@113 $generated@@114)))) - :pattern ( ($generated@@41 $generated@@112)) +(assert (forall (($generated@@114 T@U) ($generated@@115 T@T) ) (! (= ($generated@@113 $generated@@115 ($generated@@112 $generated@@115 $generated@@114)) $generated@@114) + :pattern ( ($generated@@112 $generated@@115 $generated@@114)) ))) -(assert (forall (($generated@@115 T@U) ($generated@@116 T@U) ($generated@@117 T@U) ($generated@@118 T@U) ($generated@@119 T@U) ) (! (=> ($generated@@30 $generated@@119) (= ($generated@@34 $generated@@29 ($generated@@105 $generated@@117 $generated@@118) ($generated@@33 $generated@@115 $generated@@116) $generated@@119) (and ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@117 ($generated@@90 $generated@@115) $generated@@119) ($generated@@34 $generated@@43 $generated@@118 ($generated@@85 $generated@@115 $generated@@116) $generated@@119)))) - :pattern ( ($generated@@34 $generated@@29 ($generated@@105 $generated@@117 $generated@@118) ($generated@@33 $generated@@115 $generated@@116) $generated@@119)) +(assert (forall (($generated@@116 T@U) ) (! (=> ($generated@@41 $generated@@116) (exists (($generated@@117 T@U) ($generated@@118 T@U) ) (= $generated@@116 ($generated@@105 $generated@@117 $generated@@118)))) + :pattern ( ($generated@@41 $generated@@116)) ))) -(assert ($generated@@30 $generated@@97)) -(assert (forall (($generated@@122 T@U) ($generated@@123 T@U) ($generated@@124 T@U) ($generated@@125 T@T) ) (! (= ($generated@@120 $generated@@38 ($generated@@121 $generated@@125 $generated@@122) $generated@@123 $generated@@124) ($generated@@34 $generated@@125 $generated@@122 $generated@@123 $generated@@124)) - :pattern ( ($generated@@120 $generated@@38 ($generated@@121 $generated@@125 $generated@@122) $generated@@123 $generated@@124)) -))) -(assert (forall (($generated@@126 T@U) ($generated@@127 T@U) ($generated@@128 T@T) ) (! (= ($generated@@98 $generated@@128 $generated@@126 $generated@@127) (forall (($generated@@129 T@U) ) (! (= ($generated@@15 ($generated@@37 $generated@@128 $generated@@11 $generated@@126 $generated@@129)) ($generated@@15 ($generated@@37 $generated@@128 $generated@@11 $generated@@127 $generated@@129))) - :pattern ( ($generated@@37 $generated@@128 $generated@@11 $generated@@126 $generated@@129)) - :pattern ( ($generated@@37 $generated@@128 $generated@@11 $generated@@127 $generated@@129)) +(assert (forall (($generated@@119 T@U) ($generated@@120 T@U) ($generated@@121 T@U) ($generated@@122 T@U) ($generated@@123 T@U) ) (! (=> ($generated@@30 $generated@@123) (= ($generated@@34 $generated@@29 ($generated@@105 $generated@@121 $generated@@122) ($generated@@33 $generated@@119 $generated@@120) $generated@@123) (and ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@121 ($generated@@90 $generated@@119) $generated@@123) ($generated@@34 $generated@@43 $generated@@122 ($generated@@85 $generated@@119 $generated@@120) $generated@@123)))) + :pattern ( ($generated@@34 $generated@@29 ($generated@@105 $generated@@121 $generated@@122) ($generated@@33 $generated@@119 $generated@@120) $generated@@123)) ))) - :pattern ( ($generated@@98 $generated@@128 $generated@@126 $generated@@127)) +(assert ($generated@@30 $generated@@97)) +(assert (forall (($generated@@125 T@U) ($generated@@126 T@U) ($generated@@127 T@U) ($generated@@128 T@T) ) (! (= ($generated@@124 ($generated@@113 $generated@@128 $generated@@125) $generated@@126 $generated@@127) ($generated@@34 $generated@@128 $generated@@125 $generated@@126 $generated@@127)) + :pattern ( ($generated@@124 ($generated@@113 $generated@@128 $generated@@125) $generated@@126 $generated@@127)) ))) -(assert (forall (($generated@@130 T@U) ($generated@@131 T@U) ($generated@@132 T@U) ($generated@@133 T@U) ) (! (= ($generated@@34 $generated@@43 $generated@@132 ($generated@@85 $generated@@130 $generated@@131) $generated@@133) ($generated@@34 $generated@@43 $generated@@132 ($generated@@77 $generated@@130 $generated@@131) $generated@@133)) - :pattern ( ($generated@@34 $generated@@43 $generated@@132 ($generated@@85 $generated@@130 $generated@@131) $generated@@133)) +(assert (forall (($generated@@129 T@U) ($generated@@130 T@U) ) (! (= ($generated@@98 $generated@@129 $generated@@130) (forall (($generated@@131 T@U) ) (! (= ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@129 $generated@@131)) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@130 $generated@@131))) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@129 $generated@@131)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@130 $generated@@131)) ))) -(assert (forall (($generated@@135 T@U) ($generated@@136 T@U) ($generated@@137 T@U) ($generated@@138 T@U) ) (! (=> (and ($generated@@30 $generated@@138) ($generated@@34 $generated@@43 $generated@@135 ($generated@@77 $generated@@136 $generated@@137) $generated@@138)) (forall (($generated@@139 T@U) ) (! (=> (and ($generated@@120 $generated@@38 $generated@@139 $generated@@136 $generated@@138) ($generated@@35 $generated@@136 $generated@@137 $generated@@138 $generated@@135 $generated@@139)) ($generated@@120 $generated@@38 ($generated@@134 $generated@@136 $generated@@137 $generated@@138 $generated@@135 $generated@@139) $generated@@137 $generated@@138)) - :pattern ( ($generated@@134 $generated@@136 $generated@@137 $generated@@138 $generated@@135 $generated@@139)) + :pattern ( ($generated@@98 $generated@@129 $generated@@130)) ))) - :pattern ( ($generated@@34 $generated@@43 $generated@@135 ($generated@@77 $generated@@136 $generated@@137) $generated@@138)) +(assert (forall (($generated@@132 T@U) ($generated@@133 T@U) ($generated@@134 T@U) ($generated@@135 T@U) ) (! (= ($generated@@34 $generated@@43 $generated@@134 ($generated@@85 $generated@@132 $generated@@133) $generated@@135) ($generated@@34 $generated@@43 $generated@@134 ($generated@@77 $generated@@132 $generated@@133) $generated@@135)) + :pattern ( ($generated@@34 $generated@@43 $generated@@134 ($generated@@85 $generated@@132 $generated@@133) $generated@@135)) ))) -(assert (and (and (and (and (= ($generated@@10 $generated@@140) 7) (forall (($generated@@147 T@T) ($generated@@148 T@T) ($generated@@149 T@U) ($generated@@150 T@U) ($generated@@151 T@U) ) (! (= ($generated@@143 $generated@@147 $generated@@148 ($generated@@145 $generated@@147 $generated@@148 $generated@@150 $generated@@151 $generated@@149) $generated@@151) $generated@@149) - :weight 0 -))) (and (forall (($generated@@152 T@T) ($generated@@153 T@T) ($generated@@154 T@T) ($generated@@155 T@U) ($generated@@156 T@U) ($generated@@157 T@U) ($generated@@158 T@U) ) (! (or (= $generated@@153 $generated@@154) (= ($generated@@143 $generated@@154 $generated@@152 ($generated@@145 $generated@@153 $generated@@152 $generated@@156 $generated@@157 $generated@@155) $generated@@158) ($generated@@143 $generated@@154 $generated@@152 $generated@@156 $generated@@158))) - :weight 0 -)) (forall (($generated@@159 T@T) ($generated@@160 T@T) ($generated@@161 T@T) ($generated@@162 T@U) ($generated@@163 T@U) ($generated@@164 T@U) ($generated@@165 T@U) ) (! (or (= $generated@@164 $generated@@165) (= ($generated@@143 $generated@@161 $generated@@159 ($generated@@145 $generated@@160 $generated@@159 $generated@@163 $generated@@164 $generated@@162) $generated@@165) ($generated@@143 $generated@@161 $generated@@159 $generated@@163 $generated@@165))) - :weight 0 -)))) (forall (($generated@@166 T@T) ) (= ($generated@@10 ($generated@@144 $generated@@166)) 8))) (forall (($generated@@167 T@T) ) (! (= ($generated@@146 ($generated@@144 $generated@@167)) $generated@@167) - :pattern ( ($generated@@144 $generated@@167)) -)))) -(assert (forall (($generated@@168 T@U) ($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@U) ) (! (=> ($generated@@30 $generated@@171) (= ($generated@@34 $generated@@43 $generated@@168 ($generated@@77 $generated@@169 $generated@@170) $generated@@171) (forall (($generated@@172 T@U) ) (! (=> (and (and ($generated@@40 $generated@@38 $generated@@172 $generated@@169) ($generated@@120 $generated@@38 $generated@@172 $generated@@169 $generated@@171)) ($generated@@35 $generated@@169 $generated@@170 $generated@@171 $generated@@168 $generated@@172)) (forall (($generated@@173 T@U) ) (! (=> (and (or (not (= $generated@@173 $generated@@141)) (not true)) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@169 $generated@@170 $generated@@171 $generated@@168 $generated@@172) ($generated@@121 $generated@@140 $generated@@173)))) ($generated@@15 ($generated@@142 $generated@@11 ($generated@@143 $generated@@11 $generated@@38 ($generated@@37 $generated@@140 ($generated@@144 $generated@@38) $generated@@171 $generated@@173) $generated@@2)))) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@169 $generated@@170 $generated@@171 $generated@@168 $generated@@172) ($generated@@121 $generated@@140 $generated@@173))) +(assert (forall (($generated@@137 T@U) ($generated@@138 T@U) ($generated@@139 T@U) ($generated@@140 T@U) ) (! (=> (and ($generated@@30 $generated@@140) ($generated@@34 $generated@@43 $generated@@137 ($generated@@77 $generated@@138 $generated@@139) $generated@@140)) (forall (($generated@@141 T@U) ) (! (=> (and ($generated@@124 $generated@@141 $generated@@138 $generated@@140) ($generated@@35 $generated@@138 $generated@@139 $generated@@140 $generated@@137 $generated@@141)) ($generated@@124 ($generated@@136 $generated@@138 $generated@@139 $generated@@140 $generated@@137 $generated@@141) $generated@@139 $generated@@140)) + :pattern ( ($generated@@136 $generated@@138 $generated@@139 $generated@@140 $generated@@137 $generated@@141)) ))) - :pattern ( ($generated@@134 $generated@@169 $generated@@170 $generated@@171 $generated@@168 $generated@@172)) - :pattern ( ($generated@@96 $generated@@169 $generated@@170 $generated@@171 $generated@@168 $generated@@172)) -)))) - :pattern ( ($generated@@34 $generated@@43 $generated@@168 ($generated@@77 $generated@@169 $generated@@170) $generated@@171)) + :pattern ( ($generated@@34 $generated@@43 $generated@@137 ($generated@@77 $generated@@138 $generated@@139) $generated@@140)) ))) -(assert (forall (($generated@@174 T@U) ($generated@@175 T@U) ($generated@@176 T@U) ) (! (= ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@174 ($generated@@90 $generated@@175) $generated@@176) (forall (($generated@@177 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@174 $generated@@177)) ($generated@@120 $generated@@38 $generated@@177 $generated@@175 $generated@@176)) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@174 $generated@@177)) +(assert (forall (($generated@@142 T@U) ($generated@@143 T@U) ($generated@@144 T@U) ) (! (= ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@142 ($generated@@90 $generated@@143) $generated@@144) (forall (($generated@@145 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@142 $generated@@145)) ($generated@@124 $generated@@145 $generated@@143 $generated@@144)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@142 $generated@@145)) ))) - :pattern ( ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@174 ($generated@@90 $generated@@175) $generated@@176)) + :pattern ( ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) $generated@@142 ($generated@@90 $generated@@143) $generated@@144)) ))) -(assert (forall (($generated@@178 T@U) ($generated@@179 T@U) ($generated@@180 T@T) ) (! (=> ($generated@@98 $generated@@180 $generated@@178 $generated@@179) (= $generated@@178 $generated@@179)) - :pattern ( ($generated@@98 $generated@@180 $generated@@178 $generated@@179)) +(assert (forall (($generated@@146 T@U) ($generated@@147 T@U) ) (! (=> ($generated@@98 $generated@@146 $generated@@147) (= $generated@@146 $generated@@147)) + :pattern ( ($generated@@98 $generated@@146 $generated@@147)) ))) -(assert (=> (<= 0 $generated@@26) (forall (($generated@@181 T@U) ($generated@@182 T@U) ($generated@@183 T@U) ($generated@@184 T@U) ) (! (=> (or ($generated@@31 $generated@@181 $generated@@182 $generated@@184) (and (< 0 $generated@@26) (and ($generated@@30 $generated@@183) (and ($generated@@32 $generated@@29 $generated@@184 ($generated@@33 $generated@@181 $generated@@182)) ($generated@@34 $generated@@29 $generated@@184 ($generated@@33 $generated@@181 $generated@@182) $generated@@183))))) (and (forall (($generated@@185 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@185 $generated@@181) (and ($generated@@41 $generated@@184) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@184) $generated@@185)) (and ($generated@@41 $generated@@184) true)))) - :pattern ( ($generated@@35 $generated@@181 $generated@@182 $generated@@183 ($generated@@36 $generated@@184) $generated@@185)) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@184) $generated@@185)) -)) (= ($generated@@27 $generated@@181 $generated@@182 $generated@@184) (forall (($generated@@186 T@U) ) (! (=> (and ($generated@@40 $generated@@38 $generated@@186 $generated@@181) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@184) $generated@@186))) ($generated@@35 $generated@@181 $generated@@182 $generated@@183 ($generated@@36 $generated@@184) $generated@@186)) - :pattern ( ($generated@@35 $generated@@181 $generated@@182 $generated@@183 ($generated@@36 $generated@@184) $generated@@186)) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@184) $generated@@186)) +(assert (=> (<= 0 $generated@@26) (forall (($generated@@148 T@U) ($generated@@149 T@U) ($generated@@150 T@U) ($generated@@151 T@U) ) (! (=> (or ($generated@@31 $generated@@148 $generated@@149 $generated@@151) (and (< 0 $generated@@26) (and ($generated@@30 $generated@@150) (and ($generated@@32 $generated@@29 $generated@@151 ($generated@@33 $generated@@148 $generated@@149)) ($generated@@34 $generated@@29 $generated@@151 ($generated@@33 $generated@@148 $generated@@149) $generated@@150))))) (and (forall (($generated@@152 T@U) ) (! (=> ($generated@@40 $generated@@152 $generated@@148) (and ($generated@@41 $generated@@151) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@151) $generated@@152)) (and ($generated@@41 $generated@@151) true)))) + :pattern ( ($generated@@35 $generated@@148 $generated@@149 $generated@@150 ($generated@@36 $generated@@151) $generated@@152)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@151) $generated@@152)) +)) (= ($generated@@27 $generated@@148 $generated@@149 $generated@@151) (forall (($generated@@153 T@U) ) (! (=> (and ($generated@@40 $generated@@153 $generated@@148) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@151) $generated@@153))) ($generated@@35 $generated@@148 $generated@@149 $generated@@150 ($generated@@36 $generated@@151) $generated@@153)) + :pattern ( ($generated@@35 $generated@@148 $generated@@149 $generated@@150 ($generated@@36 $generated@@151) $generated@@153)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@151) $generated@@153)) ))))) - :pattern ( ($generated@@27 $generated@@181 $generated@@182 $generated@@184) ($generated@@30 $generated@@183)) + :pattern ( ($generated@@27 $generated@@148 $generated@@149 $generated@@151) ($generated@@30 $generated@@150)) )))) -(assert (forall (($generated@@187 T@U) ($generated@@188 T@U) ($generated@@189 T@U) ) (! (= ($generated@@32 $generated@@43 $generated@@187 ($generated@@77 $generated@@188 $generated@@189)) (forall (($generated@@190 T@U) ($generated@@191 T@U) ) (! (=> (and (and ($generated@@30 $generated@@190) ($generated@@40 $generated@@38 $generated@@191 $generated@@188)) ($generated@@35 $generated@@188 $generated@@189 $generated@@190 $generated@@187 $generated@@191)) ($generated@@40 $generated@@38 ($generated@@134 $generated@@188 $generated@@189 $generated@@190 $generated@@187 $generated@@191) $generated@@189)) - :pattern ( ($generated@@134 $generated@@188 $generated@@189 $generated@@190 $generated@@187 $generated@@191)) +(assert (forall (($generated@@154 T@U) ($generated@@155 T@U) ($generated@@156 T@U) ) (! (= ($generated@@32 $generated@@43 $generated@@154 ($generated@@77 $generated@@155 $generated@@156)) (forall (($generated@@157 T@U) ($generated@@158 T@U) ) (! (=> (and (and ($generated@@30 $generated@@157) ($generated@@40 $generated@@158 $generated@@155)) ($generated@@35 $generated@@155 $generated@@156 $generated@@157 $generated@@154 $generated@@158)) ($generated@@40 ($generated@@136 $generated@@155 $generated@@156 $generated@@157 $generated@@154 $generated@@158) $generated@@156)) + :pattern ( ($generated@@136 $generated@@155 $generated@@156 $generated@@157 $generated@@154 $generated@@158)) ))) - :pattern ( ($generated@@32 $generated@@43 $generated@@187 ($generated@@77 $generated@@188 $generated@@189))) + :pattern ( ($generated@@32 $generated@@43 $generated@@154 ($generated@@77 $generated@@155 $generated@@156))) ))) -(assert (forall (($generated@@192 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@192 $generated) (and (= ($generated@@121 $generated@@11 ($generated@@142 $generated@@11 $generated@@192)) $generated@@192) ($generated@@32 $generated@@11 ($generated@@142 $generated@@11 $generated@@192) $generated))) - :pattern ( ($generated@@40 $generated@@38 $generated@@192 $generated)) +(assert (and (= ($generated@@10 $generated@@159) 7) (= ($generated@@10 $generated@@161) 8))) +(assert (forall (($generated@@162 T@U) ($generated@@163 T@U) ($generated@@164 T@U) ($generated@@165 T@U) ) (! (=> ($generated@@30 $generated@@165) (= ($generated@@34 $generated@@43 $generated@@162 ($generated@@77 $generated@@163 $generated@@164) $generated@@165) (forall (($generated@@166 T@U) ) (! (=> (and (and ($generated@@40 $generated@@166 $generated@@163) ($generated@@124 $generated@@166 $generated@@163 $generated@@165)) ($generated@@35 $generated@@163 $generated@@164 $generated@@165 $generated@@162 $generated@@166)) (forall (($generated@@167 T@U) ) (! (=> (and (or (not (= $generated@@167 $generated@@160)) (not true)) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@163 $generated@@164 $generated@@165 $generated@@162 $generated@@166) ($generated@@113 $generated@@159 $generated@@167)))) ($generated@@15 ($generated@@112 $generated@@11 ($generated@@37 $generated@@161 $generated@@38 ($generated@@37 $generated@@159 ($generated@@42 $generated@@161 $generated@@38) $generated@@165 $generated@@167) $generated@@2)))) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@163 $generated@@164 $generated@@165 $generated@@162 $generated@@166) ($generated@@113 $generated@@159 $generated@@167))) ))) -(assert (forall (($generated@@193 T@U) ($generated@@194 T@U) ($generated@@195 T@T) ) (! (= ($generated@@40 $generated@@38 ($generated@@121 $generated@@195 $generated@@193) $generated@@194) ($generated@@32 $generated@@195 $generated@@193 $generated@@194)) - :pattern ( ($generated@@40 $generated@@38 ($generated@@121 $generated@@195 $generated@@193) $generated@@194)) + :pattern ( ($generated@@136 $generated@@163 $generated@@164 $generated@@165 $generated@@162 $generated@@166)) + :pattern ( ($generated@@96 $generated@@163 $generated@@164 $generated@@165 $generated@@162 $generated@@166)) +)))) + :pattern ( ($generated@@34 $generated@@43 $generated@@162 ($generated@@77 $generated@@163 $generated@@164) $generated@@165)) ))) -(assert (forall (($generated@@197 T@U) ($generated@@198 T@U) ) (! (= ($generated@@196 ($generated@@77 $generated@@197 $generated@@198)) $generated@@197) - :pattern ( ($generated@@77 $generated@@197 $generated@@198)) +(assert (forall (($generated@@168 T@U) ) (! (=> ($generated@@40 $generated@@168 $generated) (and (= ($generated@@113 $generated@@11 ($generated@@112 $generated@@11 $generated@@168)) $generated@@168) ($generated@@32 $generated@@11 ($generated@@112 $generated@@11 $generated@@168) $generated))) + :pattern ( ($generated@@40 $generated@@168 $generated)) ))) -(assert (forall (($generated@@200 T@U) ($generated@@201 T@U) ) (! (= ($generated@@199 ($generated@@77 $generated@@200 $generated@@201)) $generated@@201) - :pattern ( ($generated@@77 $generated@@200 $generated@@201)) +(assert (forall (($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@T) ) (! (= ($generated@@40 ($generated@@113 $generated@@171 $generated@@169) $generated@@170) ($generated@@32 $generated@@171 $generated@@169 $generated@@170)) + :pattern ( ($generated@@40 ($generated@@113 $generated@@171 $generated@@169) $generated@@170)) ))) -(assert (forall (($generated@@203 T@U) ($generated@@204 T@U) ) (! (= ($generated@@202 ($generated@@85 $generated@@203 $generated@@204)) $generated@@203) - :pattern ( ($generated@@85 $generated@@203 $generated@@204)) +(assert (forall (($generated@@173 T@U) ($generated@@174 T@U) ) (! (= ($generated@@172 ($generated@@77 $generated@@173 $generated@@174)) $generated@@173) + :pattern ( ($generated@@77 $generated@@173 $generated@@174)) ))) -(assert (forall (($generated@@206 T@U) ($generated@@207 T@U) ) (! (= ($generated@@205 ($generated@@85 $generated@@206 $generated@@207)) $generated@@207) - :pattern ( ($generated@@85 $generated@@206 $generated@@207)) +(assert (forall (($generated@@176 T@U) ($generated@@177 T@U) ) (! (= ($generated@@175 ($generated@@77 $generated@@176 $generated@@177)) $generated@@177) + :pattern ( ($generated@@77 $generated@@176 $generated@@177)) ))) -(assert (forall (($generated@@208 T@U) ($generated@@209 T@U) ) (! (= ($generated@@110 ($generated@@105 $generated@@208 $generated@@209)) $generated@@5) - :pattern ( ($generated@@105 $generated@@208 $generated@@209)) +(assert (forall (($generated@@179 T@U) ($generated@@180 T@U) ) (! (= ($generated@@178 ($generated@@85 $generated@@179 $generated@@180)) $generated@@179) + :pattern ( ($generated@@85 $generated@@179 $generated@@180)) ))) -(assert (forall (($generated@@211 T@U) ($generated@@212 T@U) ) (! (= ($generated@@210 ($generated@@33 $generated@@211 $generated@@212)) $generated@@211) - :pattern ( ($generated@@33 $generated@@211 $generated@@212)) +(assert (forall (($generated@@182 T@U) ($generated@@183 T@U) ) (! (= ($generated@@181 ($generated@@85 $generated@@182 $generated@@183)) $generated@@183) + :pattern ( ($generated@@85 $generated@@182 $generated@@183)) ))) -(assert (forall (($generated@@214 T@U) ($generated@@215 T@U) ) (! (= ($generated@@213 ($generated@@33 $generated@@214 $generated@@215)) $generated@@215) - :pattern ( ($generated@@33 $generated@@214 $generated@@215)) +(assert (forall (($generated@@184 T@U) ($generated@@185 T@U) ) (! (= ($generated@@110 ($generated@@105 $generated@@184 $generated@@185)) $generated@@5) + :pattern ( ($generated@@105 $generated@@184 $generated@@185)) ))) -(assert (forall (($generated@@216 T@U) ($generated@@217 T@U) ) (! (= ($generated@@39 ($generated@@105 $generated@@216 $generated@@217)) $generated@@216) - :pattern ( ($generated@@105 $generated@@216 $generated@@217)) +(assert (forall (($generated@@187 T@U) ($generated@@188 T@U) ) (! (= ($generated@@186 ($generated@@33 $generated@@187 $generated@@188)) $generated@@187) + :pattern ( ($generated@@33 $generated@@187 $generated@@188)) ))) -(assert (forall (($generated@@218 T@U) ($generated@@219 T@U) ) (! (= ($generated@@36 ($generated@@105 $generated@@218 $generated@@219)) $generated@@219) - :pattern ( ($generated@@105 $generated@@218 $generated@@219)) +(assert (forall (($generated@@190 T@U) ($generated@@191 T@U) ) (! (= ($generated@@189 ($generated@@33 $generated@@190 $generated@@191)) $generated@@191) + :pattern ( ($generated@@33 $generated@@190 $generated@@191)) ))) -(assert (and (forall (($generated@@223 T@T) ($generated@@224 T@T) ($generated@@225 T@T) ($generated@@226 T@U) ($generated@@227 T@U) ($generated@@228 T@U) ($generated@@229 T@U) ) (! (= ($generated@@220 $generated@@223 $generated@@224 $generated@@225 ($generated@@222 $generated@@223 $generated@@224 $generated@@225 $generated@@227 $generated@@228 $generated@@229 $generated@@226) $generated@@228 $generated@@229) $generated@@226) - :weight 0 -)) (and (and (forall (($generated@@230 T@T) ($generated@@231 T@T) ($generated@@232 T@T) ($generated@@233 T@T) ($generated@@234 T@U) ($generated@@235 T@U) ($generated@@236 T@U) ($generated@@237 T@U) ($generated@@238 T@U) ($generated@@239 T@U) ) (! (or (= $generated@@232 $generated@@233) (= ($generated@@220 $generated@@233 $generated@@230 $generated@@231 ($generated@@222 $generated@@232 $generated@@230 $generated@@231 $generated@@235 $generated@@236 $generated@@237 $generated@@234) $generated@@238 $generated@@239) ($generated@@220 $generated@@233 $generated@@230 $generated@@231 $generated@@235 $generated@@238 $generated@@239))) - :weight 0 -)) (forall (($generated@@240 T@T) ($generated@@241 T@T) ($generated@@242 T@T) ($generated@@243 T@T) ($generated@@244 T@U) ($generated@@245 T@U) ($generated@@246 T@U) ($generated@@247 T@U) ($generated@@248 T@U) ($generated@@249 T@U) ) (! (or (= $generated@@246 $generated@@248) (= ($generated@@220 $generated@@243 $generated@@240 $generated@@241 ($generated@@222 $generated@@242 $generated@@240 $generated@@241 $generated@@245 $generated@@246 $generated@@247 $generated@@244) $generated@@248 $generated@@249) ($generated@@220 $generated@@243 $generated@@240 $generated@@241 $generated@@245 $generated@@248 $generated@@249))) - :weight 0 -))) (forall (($generated@@250 T@T) ($generated@@251 T@T) ($generated@@252 T@T) ($generated@@253 T@T) ($generated@@254 T@U) ($generated@@255 T@U) ($generated@@256 T@U) ($generated@@257 T@U) ($generated@@258 T@U) ($generated@@259 T@U) ) (! (or (= $generated@@257 $generated@@259) (= ($generated@@220 $generated@@253 $generated@@250 $generated@@251 ($generated@@222 $generated@@252 $generated@@250 $generated@@251 $generated@@255 $generated@@256 $generated@@257 $generated@@254) $generated@@258 $generated@@259) ($generated@@220 $generated@@253 $generated@@250 $generated@@251 $generated@@255 $generated@@258 $generated@@259))) - :weight 0 -))))) -(assert (forall (($generated@@260 T@U) ($generated@@261 T@U) ($generated@@262 T@U) ($generated@@263 Bool) ($generated@@264 T@U) ($generated@@265 T@U) ($generated@@266 T@T) ) (! (= ($generated@@15 ($generated@@220 $generated@@266 $generated@@140 $generated@@11 ($generated@@221 $generated@@260 $generated@@261 $generated@@262 $generated@@263) $generated@@264 $generated@@265)) (=> (and (or (not (= $generated@@264 $generated@@260)) (not true)) ($generated@@15 ($generated@@142 $generated@@11 ($generated@@143 $generated@@11 $generated@@38 ($generated@@37 $generated@@140 ($generated@@144 $generated@@38) $generated@@261 $generated@@264) $generated@@262)))) $generated@@263)) - :pattern ( ($generated@@220 $generated@@266 $generated@@140 $generated@@11 ($generated@@221 $generated@@260 $generated@@261 $generated@@262 $generated@@263) $generated@@264 $generated@@265)) +(assert (forall (($generated@@192 T@U) ($generated@@193 T@U) ) (! (= ($generated@@39 ($generated@@105 $generated@@192 $generated@@193)) $generated@@192) + :pattern ( ($generated@@105 $generated@@192 $generated@@193)) ))) -(assert (forall (($generated@@268 T@U) ) (! (= ($generated@@267 ($generated@@90 $generated@@268)) $generated@@268) - :pattern ( ($generated@@90 $generated@@268)) +(assert (forall (($generated@@194 T@U) ($generated@@195 T@U) ) (! (= ($generated@@36 ($generated@@105 $generated@@194 $generated@@195)) $generated@@195) + :pattern ( ($generated@@105 $generated@@194 $generated@@195)) ))) -(assert (forall (($generated@@269 T@U) ) (! (= ($generated@@70 ($generated@@90 $generated@@269)) $generated@@1) - :pattern ( ($generated@@90 $generated@@269)) +(assert (forall (($generated@@197 T@U) ) (! (= ($generated@@196 ($generated@@90 $generated@@197)) $generated@@197) + :pattern ( ($generated@@90 $generated@@197)) ))) -(assert (forall (($generated@@270 T@U) ($generated@@271 T@T) ) (! (= ($generated@@142 $generated@@271 ($generated@@121 $generated@@271 $generated@@270)) $generated@@270) - :pattern ( ($generated@@121 $generated@@271 $generated@@270)) +(assert (forall (($generated@@198 T@U) ) (! (= ($generated@@70 ($generated@@90 $generated@@198)) $generated@@1) + :pattern ( ($generated@@90 $generated@@198)) ))) -(assert (forall (($generated@@273 T@U) ($generated@@274 T@U) ($generated@@275 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@273 ($generated@@121 $generated@@29 $generated@@275))) (< ($generated@@272 $generated@@275) ($generated@@272 ($generated@@105 $generated@@273 $generated@@274)))) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@273 ($generated@@121 $generated@@29 $generated@@275)) ($generated@@105 $generated@@273 $generated@@274)) +(assert (forall (($generated@@199 T@U) ($generated@@200 T@T) ) (! (= ($generated@@112 $generated@@200 ($generated@@113 $generated@@200 $generated@@199)) $generated@@199) + :pattern ( ($generated@@113 $generated@@200 $generated@@199)) ))) -(assert (forall (($generated@@276 T@U) ($generated@@277 T@U) ($generated@@278 T@U) ) (! (= ($generated@@32 $generated@@43 $generated@@278 ($generated@@85 $generated@@276 $generated@@277)) (and ($generated@@32 $generated@@43 $generated@@278 ($generated@@77 $generated@@276 $generated@@277)) (forall (($generated@@279 T@U) ) (=> ($generated@@40 $generated@@38 $generated@@279 $generated@@276) ($generated@@98 $generated@@38 ($generated@@96 $generated@@276 $generated@@277 $generated@@97 $generated@@278 $generated@@279) ($generated@@99 $generated@@38)))))) - :pattern ( ($generated@@32 $generated@@43 $generated@@278 ($generated@@85 $generated@@276 $generated@@277))) +(assert (forall (($generated@@202 T@U) ($generated@@203 T@U) ($generated@@204 T@U) ) (! (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@202 ($generated@@113 $generated@@29 $generated@@204))) (< ($generated@@201 $generated@@204) ($generated@@201 ($generated@@105 $generated@@202 $generated@@203)))) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@202 ($generated@@113 $generated@@29 $generated@@204)) ($generated@@105 $generated@@202 $generated@@203)) ))) -(assert (forall (($generated@@280 T@U) ($generated@@281 T@U) ($generated@@282 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@282 ($generated@@77 $generated@@280 $generated@@281)) (and (= ($generated@@121 $generated@@43 ($generated@@142 $generated@@43 $generated@@282)) $generated@@282) ($generated@@32 $generated@@43 ($generated@@142 $generated@@43 $generated@@282) ($generated@@77 $generated@@280 $generated@@281)))) - :pattern ( ($generated@@40 $generated@@38 $generated@@282 ($generated@@77 $generated@@280 $generated@@281))) +(assert (forall (($generated@@205 T@U) ($generated@@206 T@U) ($generated@@207 T@U) ) (! (= ($generated@@32 $generated@@43 $generated@@207 ($generated@@85 $generated@@205 $generated@@206)) (and ($generated@@32 $generated@@43 $generated@@207 ($generated@@77 $generated@@205 $generated@@206)) (forall (($generated@@208 T@U) ) (=> ($generated@@40 $generated@@208 $generated@@205) ($generated@@98 ($generated@@96 $generated@@205 $generated@@206 $generated@@97 $generated@@207 $generated@@208) $generated@@99))))) + :pattern ( ($generated@@32 $generated@@43 $generated@@207 ($generated@@85 $generated@@205 $generated@@206))) ))) -(assert (forall (($generated@@283 T@U) ($generated@@284 T@U) ($generated@@285 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@285 ($generated@@85 $generated@@283 $generated@@284)) (and (= ($generated@@121 $generated@@43 ($generated@@142 $generated@@43 $generated@@285)) $generated@@285) ($generated@@32 $generated@@43 ($generated@@142 $generated@@43 $generated@@285) ($generated@@85 $generated@@283 $generated@@284)))) - :pattern ( ($generated@@40 $generated@@38 $generated@@285 ($generated@@85 $generated@@283 $generated@@284))) +(assert (forall (($generated@@209 T@U) ($generated@@210 T@U) ($generated@@211 T@U) ) (! (=> ($generated@@40 $generated@@211 ($generated@@77 $generated@@209 $generated@@210)) (and (= ($generated@@113 $generated@@43 ($generated@@112 $generated@@43 $generated@@211)) $generated@@211) ($generated@@32 $generated@@43 ($generated@@112 $generated@@43 $generated@@211) ($generated@@77 $generated@@209 $generated@@210)))) + :pattern ( ($generated@@40 $generated@@211 ($generated@@77 $generated@@209 $generated@@210))) ))) -(assert (forall (($generated@@286 T@U) ($generated@@287 T@U) ($generated@@288 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@288 ($generated@@33 $generated@@286 $generated@@287)) (and (= ($generated@@121 $generated@@29 ($generated@@142 $generated@@29 $generated@@288)) $generated@@288) ($generated@@32 $generated@@29 ($generated@@142 $generated@@29 $generated@@288) ($generated@@33 $generated@@286 $generated@@287)))) - :pattern ( ($generated@@40 $generated@@38 $generated@@288 ($generated@@33 $generated@@286 $generated@@287))) +(assert (forall (($generated@@212 T@U) ($generated@@213 T@U) ($generated@@214 T@U) ) (! (=> ($generated@@40 $generated@@214 ($generated@@85 $generated@@212 $generated@@213)) (and (= ($generated@@113 $generated@@43 ($generated@@112 $generated@@43 $generated@@214)) $generated@@214) ($generated@@32 $generated@@43 ($generated@@112 $generated@@43 $generated@@214) ($generated@@85 $generated@@212 $generated@@213)))) + :pattern ( ($generated@@40 $generated@@214 ($generated@@85 $generated@@212 $generated@@213))) ))) -(assert (forall (($generated@@289 T@U) ($generated@@290 T@T) ) (! (not ($generated@@15 ($generated@@37 $generated@@290 $generated@@11 ($generated@@99 $generated@@290) $generated@@289))) - :pattern ( ($generated@@37 $generated@@290 $generated@@11 ($generated@@99 $generated@@290) $generated@@289)) +(assert (forall (($generated@@215 T@U) ($generated@@216 T@U) ($generated@@217 T@U) ) (! (=> ($generated@@40 $generated@@217 ($generated@@33 $generated@@215 $generated@@216)) (and (= ($generated@@113 $generated@@29 ($generated@@112 $generated@@29 $generated@@217)) $generated@@217) ($generated@@32 $generated@@29 ($generated@@112 $generated@@29 $generated@@217) ($generated@@33 $generated@@215 $generated@@216)))) + :pattern ( ($generated@@40 $generated@@217 ($generated@@33 $generated@@215 $generated@@216))) ))) -(assert (forall (($generated@@292 T@U) ($generated@@293 T@U) ) (! (and (= ($generated@@70 ($generated@@77 $generated@@292 $generated@@293)) $generated@@3) (= ($generated@@291 ($generated@@77 $generated@@292 $generated@@293)) $generated@@7)) - :pattern ( ($generated@@77 $generated@@292 $generated@@293)) +(assert (forall (($generated@@218 T@U) ) (! (not ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 $generated@@99 $generated@@218))) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 $generated@@99 $generated@@218)) ))) -(assert (forall (($generated@@294 T@U) ($generated@@295 T@U) ) (! (and (= ($generated@@70 ($generated@@85 $generated@@294 $generated@@295)) $generated@@4) (= ($generated@@291 ($generated@@85 $generated@@294 $generated@@295)) $generated@@8)) - :pattern ( ($generated@@85 $generated@@294 $generated@@295)) +(assert (and (forall (($generated@@222 T@T) ($generated@@223 T@T) ($generated@@224 T@T) ($generated@@225 T@U) ($generated@@226 T@U) ($generated@@227 T@U) ($generated@@228 T@U) ) (! (= ($generated@@219 $generated@@222 $generated@@223 $generated@@224 ($generated@@221 $generated@@222 $generated@@223 $generated@@224 $generated@@226 $generated@@227 $generated@@228 $generated@@225) $generated@@227 $generated@@228) $generated@@225) + :weight 0 +)) (and (forall (($generated@@229 T@T) ($generated@@230 T@T) ($generated@@231 T@T) ($generated@@232 T@U) ($generated@@233 T@U) ($generated@@234 T@U) ($generated@@235 T@U) ($generated@@236 T@U) ($generated@@237 T@U) ) (! (or (= $generated@@234 $generated@@236) (= ($generated@@219 $generated@@229 $generated@@230 $generated@@231 ($generated@@221 $generated@@229 $generated@@230 $generated@@231 $generated@@233 $generated@@234 $generated@@235 $generated@@232) $generated@@236 $generated@@237) ($generated@@219 $generated@@229 $generated@@230 $generated@@231 $generated@@233 $generated@@236 $generated@@237))) + :weight 0 +)) (forall (($generated@@238 T@T) ($generated@@239 T@T) ($generated@@240 T@T) ($generated@@241 T@U) ($generated@@242 T@U) ($generated@@243 T@U) ($generated@@244 T@U) ($generated@@245 T@U) ($generated@@246 T@U) ) (! (or (= $generated@@244 $generated@@246) (= ($generated@@219 $generated@@238 $generated@@239 $generated@@240 ($generated@@221 $generated@@238 $generated@@239 $generated@@240 $generated@@242 $generated@@243 $generated@@244 $generated@@241) $generated@@245 $generated@@246) ($generated@@219 $generated@@238 $generated@@239 $generated@@240 $generated@@242 $generated@@245 $generated@@246))) + :weight 0 +))))) +(assert (forall (($generated@@247 T@U) ($generated@@248 T@U) ($generated@@249 T@U) ($generated@@250 Bool) ($generated@@251 T@U) ($generated@@252 T@U) ) (! (= ($generated@@15 ($generated@@219 $generated@@159 $generated@@161 $generated@@11 ($generated@@220 $generated@@247 $generated@@248 $generated@@249 $generated@@250) $generated@@251 $generated@@252)) (=> (and (or (not (= $generated@@251 $generated@@247)) (not true)) ($generated@@15 ($generated@@112 $generated@@11 ($generated@@37 $generated@@161 $generated@@38 ($generated@@37 $generated@@159 ($generated@@42 $generated@@161 $generated@@38) $generated@@248 $generated@@251) $generated@@249)))) $generated@@250)) + :pattern ( ($generated@@219 $generated@@159 $generated@@161 $generated@@11 ($generated@@220 $generated@@247 $generated@@248 $generated@@249 $generated@@250) $generated@@251 $generated@@252)) ))) -(assert (forall (($generated@@296 T@U) ($generated@@297 T@U) ) (! (and (= ($generated@@70 ($generated@@33 $generated@@296 $generated@@297)) $generated@@6) (= ($generated@@291 ($generated@@33 $generated@@296 $generated@@297)) $generated@@9)) - :pattern ( ($generated@@33 $generated@@296 $generated@@297)) +(assert (forall (($generated@@254 T@U) ($generated@@255 T@U) ) (! (and (= ($generated@@70 ($generated@@77 $generated@@254 $generated@@255)) $generated@@3) (= ($generated@@253 ($generated@@77 $generated@@254 $generated@@255)) $generated@@7)) + :pattern ( ($generated@@77 $generated@@254 $generated@@255)) ))) -(assert (forall (($generated@@298 T@U) ($generated@@299 T@U) ($generated@@300 T@U) ($generated@@301 T@U) ($generated@@302 T@U) ) (! (=> (and (and ($generated@@30 $generated@@300) (and ($generated@@40 $generated@@38 $generated@@302 $generated@@298) ($generated@@32 $generated@@43 $generated@@301 ($generated@@77 $generated@@298 $generated@@299)))) ($generated@@98 $generated@@38 ($generated@@96 $generated@@298 $generated@@299 $generated@@97 $generated@@301 $generated@@302) ($generated@@99 $generated@@38))) (= ($generated@@35 $generated@@298 $generated@@299 $generated@@97 $generated@@301 $generated@@302) ($generated@@35 $generated@@298 $generated@@299 $generated@@300 $generated@@301 $generated@@302))) - :pattern ( ($generated@@35 $generated@@298 $generated@@299 $generated@@97 $generated@@301 $generated@@302) ($generated@@30 $generated@@300)) - :pattern ( ($generated@@35 $generated@@298 $generated@@299 $generated@@300 $generated@@301 $generated@@302)) +(assert (forall (($generated@@256 T@U) ($generated@@257 T@U) ) (! (and (= ($generated@@70 ($generated@@85 $generated@@256 $generated@@257)) $generated@@4) (= ($generated@@253 ($generated@@85 $generated@@256 $generated@@257)) $generated@@8)) + :pattern ( ($generated@@85 $generated@@256 $generated@@257)) ))) -(assert (forall (($generated@@303 T@U) ($generated@@304 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@303 ($generated@@90 $generated@@304)) (and (= ($generated@@121 ($generated@@42 $generated@@38 $generated@@11) ($generated@@142 ($generated@@42 $generated@@38 $generated@@11) $generated@@303)) $generated@@303) ($generated@@32 ($generated@@42 $generated@@38 $generated@@11) ($generated@@142 ($generated@@42 $generated@@38 $generated@@11) $generated@@303) ($generated@@90 $generated@@304)))) - :pattern ( ($generated@@40 $generated@@38 $generated@@303 ($generated@@90 $generated@@304))) +(assert (forall (($generated@@258 T@U) ($generated@@259 T@U) ) (! (and (= ($generated@@70 ($generated@@33 $generated@@258 $generated@@259)) $generated@@6) (= ($generated@@253 ($generated@@33 $generated@@258 $generated@@259)) $generated@@9)) + :pattern ( ($generated@@33 $generated@@258 $generated@@259)) ))) -(assert (forall (($generated@@305 T@U) ($generated@@306 T@U) ) (! (= ($generated@@105 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) $generated@@305) ($generated@@28 $generated@@43 $generated@@306)) ($generated@@28 $generated@@29 ($generated@@105 $generated@@305 $generated@@306))) - :pattern ( ($generated@@105 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) $generated@@305) ($generated@@28 $generated@@43 $generated@@306))) +(assert (forall (($generated@@260 T@U) ($generated@@261 T@U) ($generated@@262 T@U) ($generated@@263 T@U) ($generated@@264 T@U) ) (! (=> (and (and ($generated@@30 $generated@@262) (and ($generated@@40 $generated@@264 $generated@@260) ($generated@@32 $generated@@43 $generated@@263 ($generated@@77 $generated@@260 $generated@@261)))) ($generated@@98 ($generated@@96 $generated@@260 $generated@@261 $generated@@97 $generated@@263 $generated@@264) $generated@@99)) (= ($generated@@35 $generated@@260 $generated@@261 $generated@@97 $generated@@263 $generated@@264) ($generated@@35 $generated@@260 $generated@@261 $generated@@262 $generated@@263 $generated@@264))) + :pattern ( ($generated@@35 $generated@@260 $generated@@261 $generated@@97 $generated@@263 $generated@@264) ($generated@@30 $generated@@262)) + :pattern ( ($generated@@35 $generated@@260 $generated@@261 $generated@@262 $generated@@263 $generated@@264)) ))) -(assert (forall (($generated@@307 T@U) ($generated@@308 T@T) ) (! (= ($generated@@121 $generated@@308 ($generated@@28 $generated@@308 $generated@@307)) ($generated@@28 $generated@@38 ($generated@@121 $generated@@308 $generated@@307))) - :pattern ( ($generated@@121 $generated@@308 ($generated@@28 $generated@@308 $generated@@307))) +(assert (forall (($generated@@265 T@U) ($generated@@266 T@U) ) (! (=> ($generated@@40 $generated@@265 ($generated@@90 $generated@@266)) (and (= ($generated@@113 ($generated@@42 $generated@@38 $generated@@11) ($generated@@112 ($generated@@42 $generated@@38 $generated@@11) $generated@@265)) $generated@@265) ($generated@@32 ($generated@@42 $generated@@38 $generated@@11) ($generated@@112 ($generated@@42 $generated@@38 $generated@@11) $generated@@265) ($generated@@90 $generated@@266)))) + :pattern ( ($generated@@40 $generated@@265 ($generated@@90 $generated@@266))) ))) -(assert (forall (($generated@@309 T@U) ($generated@@310 T@U) ($generated@@311 T@U) ) (! (=> (and ($generated@@30 $generated@@311) (and ($generated@@41 $generated@@309) (exists (($generated@@312 T@U) ) (! ($generated@@34 $generated@@29 $generated@@309 ($generated@@33 $generated@@310 $generated@@312) $generated@@311) - :pattern ( ($generated@@34 $generated@@29 $generated@@309 ($generated@@33 $generated@@310 $generated@@312) $generated@@311)) -)))) ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 $generated@@309) ($generated@@90 $generated@@310) $generated@@311)) - :pattern ( ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 $generated@@309) ($generated@@90 $generated@@310) $generated@@311)) +(assert (forall (($generated@@267 T@U) ($generated@@268 T@U) ) (! (= ($generated@@105 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) $generated@@267) ($generated@@28 $generated@@43 $generated@@268)) ($generated@@28 $generated@@29 ($generated@@105 $generated@@267 $generated@@268))) + :pattern ( ($generated@@105 ($generated@@28 ($generated@@42 $generated@@38 $generated@@11) $generated@@267) ($generated@@28 $generated@@43 $generated@@268))) ))) -(assert (forall (($generated@@313 T@U) ($generated@@314 T@U) ) (! ($generated@@34 $generated@@11 $generated@@314 $generated $generated@@313) - :pattern ( ($generated@@34 $generated@@11 $generated@@314 $generated $generated@@313)) +(assert (forall (($generated@@269 T@U) ($generated@@270 T@T) ) (! (= ($generated@@113 $generated@@270 ($generated@@28 $generated@@270 $generated@@269)) ($generated@@28 $generated@@38 ($generated@@113 $generated@@270 $generated@@269))) + :pattern ( ($generated@@113 $generated@@270 ($generated@@28 $generated@@270 $generated@@269))) ))) -(assert (forall (($generated@@315 T@U) ) (! ($generated@@32 $generated@@11 $generated@@315 $generated) - :pattern ( ($generated@@32 $generated@@11 $generated@@315 $generated)) +(assert (forall (($generated@@271 T@U) ($generated@@272 T@U) ($generated@@273 T@U) ) (! (=> (and ($generated@@30 $generated@@273) (and ($generated@@41 $generated@@271) (exists (($generated@@274 T@U) ) (! ($generated@@34 $generated@@29 $generated@@271 ($generated@@33 $generated@@272 $generated@@274) $generated@@273) + :pattern ( ($generated@@34 $generated@@29 $generated@@271 ($generated@@33 $generated@@272 $generated@@274) $generated@@273)) +)))) ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 $generated@@271) ($generated@@90 $generated@@272) $generated@@273)) + :pattern ( ($generated@@34 ($generated@@42 $generated@@38 $generated@@11) ($generated@@39 $generated@@271) ($generated@@90 $generated@@272) $generated@@273)) +))) +(assert (forall (($generated@@275 T@U) ($generated@@276 T@U) ) (! ($generated@@34 $generated@@11 $generated@@276 $generated $generated@@275) + :pattern ( ($generated@@34 $generated@@11 $generated@@276 $generated $generated@@275)) +))) +(assert (forall (($generated@@277 T@U) ) (! ($generated@@32 $generated@@11 $generated@@277 $generated) + :pattern ( ($generated@@32 $generated@@11 $generated@@277 $generated)) ))) (push 1) (declare-fun ControlFlow (Int Int) Int) -(declare-fun $generated@@316 () T@U) -(declare-fun $generated@@317 () T@U) -(declare-fun $generated@@318 () T@U) -(declare-fun $generated@@319 () T@U) -(declare-fun $generated@@320 () Bool) -(declare-fun $generated@@321 () T@U) -(declare-fun $generated@@322 () Bool) -(declare-fun $generated@@323 () T@U) -(declare-fun $generated@@324 (T@U) Bool) +(declare-fun $generated@@278 () T@U) +(declare-fun $generated@@279 () T@U) +(declare-fun $generated@@280 () T@U) +(declare-fun $generated@@281 () T@U) +(declare-fun $generated@@282 () Bool) +(declare-fun $generated@@283 () T@U) +(declare-fun $generated@@284 () Bool) +(declare-fun $generated@@285 () T@U) +(declare-fun $generated@@286 (T@U) Bool) (set-option :timeout 0) (set-option :rlimit 0) (set-option :auto_config false) @@ -1428,21 +1391,21 @@ $generated@@523)))))))) (set-option :pp.bv_literals false) (set-option :smt.arith.solver 2) (assert (not - (=> (= (ControlFlow 0 0) 9) (let (($generated@@325 (=> (and (and (= ($generated@@27 $generated@@316 $generated@@317 $generated@@318) (forall (($generated@@326 T@U) ) (! (=> (and ($generated@@40 $generated@@38 $generated@@326 $generated@@316) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@326))) ($generated@@35 $generated@@316 $generated@@317 $generated@@319 ($generated@@36 $generated@@318) $generated@@326)) - :pattern ( ($generated@@35 $generated@@316 $generated@@317 $generated@@319 ($generated@@36 $generated@@318) $generated@@326)) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@326)) -))) (forall (($generated@@327 T@U) ) (! (=> ($generated@@40 $generated@@38 $generated@@327 $generated@@316) (and ($generated@@41 $generated@@318) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@327)) (and ($generated@@41 $generated@@318) true)))) - :pattern ( ($generated@@35 $generated@@316 $generated@@317 $generated@@319 ($generated@@36 $generated@@318) $generated@@327)) - :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@327)) -))) (and ($generated@@32 $generated@@11 ($generated@@14 ($generated@@27 $generated@@316 $generated@@317 $generated@@318)) $generated) (= (ControlFlow 0 3) (- 0 2)))) $generated@@320))) -(let (($generated@@328 (=> (not ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@321))) (=> (and (= $generated@@320 true) (= (ControlFlow 0 6) 3)) $generated@@325)))) -(let (($generated@@329 (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@318) $generated@@321)) (=> (and ($generated@@41 $generated@@318) ($generated@@34 $generated@@43 ($generated@@36 $generated@@318) ($generated@@77 $generated@@316 $generated@@317) $generated@@319)) (=> (and (and ($generated@@120 $generated@@38 $generated@@321 $generated@@316 $generated@@319) (= $generated@@322 (forall (($generated@@330 T@U) ($generated@@331 T@U) ($generated@@332 T@T) ) (=> (and (and (or (not (= $generated@@330 $generated@@141)) (not true)) ($generated@@15 ($generated@@142 $generated@@11 ($generated@@143 $generated@@11 $generated@@38 ($generated@@37 $generated@@140 ($generated@@144 $generated@@38) $generated@@319 $generated@@330) $generated@@2)))) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@316 $generated@@317 $generated@@319 ($generated@@36 $generated@@318) $generated@@321) ($generated@@121 $generated@@140 $generated@@330)))) ($generated@@15 ($generated@@220 $generated@@332 $generated@@140 $generated@@11 $generated@@323 $generated@@330 $generated@@331)))))) (and (= $generated@@320 $generated@@322) (= (ControlFlow 0 5) 3))) $generated@@325))))) -(let (($generated@@333 (=> (and (and ($generated@@40 $generated@@38 $generated@@321 $generated@@316) ($generated@@120 $generated@@38 $generated@@321 $generated@@316 $generated@@319)) ($generated@@41 $generated@@318)) (and (=> (= (ControlFlow 0 7) 5) $generated@@329) (=> (= (ControlFlow 0 7) 6) $generated@@328))))) -(let (($generated@@334 (=> (not (and ($generated@@40 $generated@@38 $generated@@321 $generated@@316) ($generated@@120 $generated@@38 $generated@@321 $generated@@316 $generated@@319))) (=> (and (= $generated@@320 true) (= (ControlFlow 0 4) 3)) $generated@@325)))) -(let (($generated@@335 true)) -(let (($generated@@336 (=> (= $generated@@323 ($generated@@221 $generated@@141 $generated@@319 $generated@@2 false)) (and (and (=> (= (ControlFlow 0 8) 1) $generated@@335) (=> (= (ControlFlow 0 8) 7) $generated@@333)) (=> (= (ControlFlow 0 8) 4) $generated@@334))))) -(let (($generated@@337 (=> (and ($generated@@30 $generated@@319) ($generated@@324 $generated@@319)) (=> (and (and ($generated@@32 $generated@@29 $generated@@318 ($generated@@33 $generated@@316 $generated@@317)) ($generated@@34 $generated@@29 $generated@@318 ($generated@@33 $generated@@316 $generated@@317) $generated@@319)) (and (= 0 $generated@@26) (= (ControlFlow 0 9) 8))) $generated@@336)))) -$generated@@337))))))))) + (=> (= (ControlFlow 0 0) 9) (let (($generated@@287 (=> (and (and (= ($generated@@27 $generated@@278 $generated@@279 $generated@@280) (forall (($generated@@288 T@U) ) (! (=> (and ($generated@@40 $generated@@288 $generated@@278) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@288))) ($generated@@35 $generated@@278 $generated@@279 $generated@@281 ($generated@@36 $generated@@280) $generated@@288)) + :pattern ( ($generated@@35 $generated@@278 $generated@@279 $generated@@281 ($generated@@36 $generated@@280) $generated@@288)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@288)) +))) (forall (($generated@@289 T@U) ) (! (=> ($generated@@40 $generated@@289 $generated@@278) (and ($generated@@41 $generated@@280) (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@289)) (and ($generated@@41 $generated@@280) true)))) + :pattern ( ($generated@@35 $generated@@278 $generated@@279 $generated@@281 ($generated@@36 $generated@@280) $generated@@289)) + :pattern ( ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@289)) +))) (and ($generated@@32 $generated@@11 ($generated@@14 ($generated@@27 $generated@@278 $generated@@279 $generated@@280)) $generated) (= (ControlFlow 0 3) (- 0 2)))) $generated@@282))) +(let (($generated@@290 (=> (not ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@283))) (=> (and (= $generated@@282 true) (= (ControlFlow 0 6) 3)) $generated@@287)))) +(let (($generated@@291 (=> ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@39 $generated@@280) $generated@@283)) (=> (and ($generated@@41 $generated@@280) ($generated@@124 ($generated@@113 $generated@@43 ($generated@@36 $generated@@280)) ($generated@@77 $generated@@278 $generated@@279) $generated@@281)) (=> (and (and ($generated@@124 $generated@@283 $generated@@278 $generated@@281) (= $generated@@284 (forall (($generated@@292 T@U) ($generated@@293 T@U) ) (=> (and (and (or (not (= $generated@@292 $generated@@160)) (not true)) ($generated@@15 ($generated@@112 $generated@@11 ($generated@@37 $generated@@161 $generated@@38 ($generated@@37 $generated@@159 ($generated@@42 $generated@@161 $generated@@38) $generated@@281 $generated@@292) $generated@@2)))) ($generated@@15 ($generated@@37 $generated@@38 $generated@@11 ($generated@@96 $generated@@278 $generated@@279 $generated@@281 ($generated@@36 $generated@@280) $generated@@283) ($generated@@113 $generated@@159 $generated@@292)))) ($generated@@15 ($generated@@219 $generated@@159 $generated@@161 $generated@@11 $generated@@285 $generated@@292 $generated@@293)))))) (and (= $generated@@282 $generated@@284) (= (ControlFlow 0 5) 3))) $generated@@287))))) +(let (($generated@@294 (=> (and (and ($generated@@40 $generated@@283 $generated@@278) ($generated@@124 $generated@@283 $generated@@278 $generated@@281)) ($generated@@41 $generated@@280)) (and (=> (= (ControlFlow 0 7) 5) $generated@@291) (=> (= (ControlFlow 0 7) 6) $generated@@290))))) +(let (($generated@@295 (=> (not (and ($generated@@40 $generated@@283 $generated@@278) ($generated@@124 $generated@@283 $generated@@278 $generated@@281))) (=> (and (= $generated@@282 true) (= (ControlFlow 0 4) 3)) $generated@@287)))) +(let (($generated@@296 true)) +(let (($generated@@297 (=> (= $generated@@285 ($generated@@220 $generated@@160 $generated@@281 $generated@@2 false)) (and (and (=> (= (ControlFlow 0 8) 1) $generated@@296) (=> (= (ControlFlow 0 8) 7) $generated@@294)) (=> (= (ControlFlow 0 8) 4) $generated@@295))))) +(let (($generated@@298 (=> (and ($generated@@30 $generated@@281) ($generated@@286 $generated@@281)) (=> (and (and ($generated@@32 $generated@@29 $generated@@280 ($generated@@33 $generated@@278 $generated@@279)) ($generated@@34 $generated@@29 $generated@@280 ($generated@@33 $generated@@278 $generated@@279) $generated@@281)) (and (= 0 $generated@@26) (= (ControlFlow 0 9) 8))) $generated@@297)))) +$generated@@298))))))))) )) (check-sat) (get-info :rlimit) @@ -1516,65 +1479,59 @@ $generated@@337))))))))) (declare-fun $generated@@41 (T@T T@T T@U T@U) T@U) (declare-fun $generated@@42 () T@T) (declare-fun $generated@@43 (T@U) T@U) -(declare-fun $generated@@44 (T@T T@U T@U) Bool) +(declare-fun $generated@@44 (T@U T@U) Bool) (declare-fun $generated@@45 (T@U) Bool) (declare-fun $generated@@46 (T@T T@T) T@T) (declare-fun $generated@@47 () T@T) (declare-fun $generated@@48 (T@T T@T T@U T@U T@U) T@U) (declare-fun $generated@@49 (T@T) T@T) (declare-fun $generated@@50 (T@T) T@T) -(declare-fun $generated@@74 (T@U T@U) Bool) -(declare-fun $generated@@75 (T@T T@U) T@U) -(declare-fun $generated@@76 (T@T T@T T@U T@U) T@U) -(declare-fun $generated@@77 () T@T) -(declare-fun $generated@@78 (T@T) T@T) -(declare-fun $generated@@79 (T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@80 (T@T) T@T) -(declare-fun $generated@@108 () T@U) -(declare-fun $generated@@109 () T@U) -(declare-fun $generated@@115 (T@U) T@U) -(declare-fun $generated@@116 () T@U) -(declare-fun $generated@@117 (T@U T@U) T@U) -(declare-fun $generated@@125 () T@U) +(declare-fun $generated@@80 (T@U) T@U) +(declare-fun $generated@@81 () T@U) +(declare-fun $generated@@82 (T@U T@U) T@U) +(declare-fun $generated@@90 () T@U) +(declare-fun $generated@@91 () T@T) +(declare-fun $generated@@92 () T@U) +(declare-fun $generated@@93 () T@U) +(declare-fun $generated@@94 (T@T T@U) T@U) +(declare-fun $generated@@95 () T@T) +(declare-fun $generated@@98 (T@U T@U) T@U) +(declare-fun $generated@@103 (T@U T@U) Bool) +(declare-fun $generated@@107 (T@U) T@U) +(declare-fun $generated@@111 (T@U) T@U) +(declare-fun $generated@@117 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@118 () T@U) +(declare-fun $generated@@119 (T@U T@U) Bool) +(declare-fun $generated@@120 () T@U) (declare-fun $generated@@126 (T@U T@U) T@U) -(declare-fun $generated@@131 (T@U) T@U) -(declare-fun $generated@@135 (T@U) T@U) -(declare-fun $generated@@141 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@142 () T@U) -(declare-fun $generated@@143 (T@T T@U T@U) Bool) -(declare-fun $generated@@144 (T@T) T@U) -(declare-fun $generated@@150 (T@U T@U) T@U) -(declare-fun $generated@@159 (T@U) T@U) -(declare-fun $generated@@162 (T@T T@U T@U) T@U) -(declare-fun $generated@@163 () T@T) -(declare-fun $generated@@172 (T@T T@U T@U T@U) Bool) -(declare-fun $generated@@173 (T@T T@U) T@U) -(declare-fun $generated@@195 (T@U T@U T@U T@U T@U) T@U) -(declare-fun $generated@@196 (T@U T@U T@U) T@U) -(declare-fun $generated@@197 (T@T T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@198 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@244 (Bool) T@U) -(declare-fun $generated@@247 (T@U) T@U) -(declare-fun $generated@@293 (T@U) T@U) +(declare-fun $generated@@132 (T@T T@U) T@U) +(declare-fun $generated@@138 (T@U) T@U) +(declare-fun $generated@@141 (T@T T@U T@U) T@U) +(declare-fun $generated@@142 () T@T) +(declare-fun $generated@@151 (T@U T@U T@U) Bool) +(declare-fun $generated@@172 (T@U T@U T@U T@U T@U) T@U) +(declare-fun $generated@@173 (T@U T@U T@U) T@U) +(declare-fun $generated@@174 (T@T T@T T@T T@U T@U T@U) T@U) +(declare-fun $generated@@175 (T@T T@T T@T T@U T@U T@U T@U) T@U) +(declare-fun $generated@@215 (Bool) T@U) +(declare-fun $generated@@218 (T@U) T@U) +(declare-fun $generated@@269 (T@U) T@U) +(declare-fun $generated@@272 (T@U) T@U) +(declare-fun $generated@@275 (T@U) T@U) +(declare-fun $generated@@278 (T@U) T@U) +(declare-fun $generated@@283 (T@U) T@U) +(declare-fun $generated@@286 (T@U) T@U) +(declare-fun $generated@@294 (T@U) T@U) (declare-fun $generated@@296 (T@U) T@U) -(declare-fun $generated@@299 (T@U) T@U) -(declare-fun $generated@@302 (T@U) T@U) -(declare-fun $generated@@307 (T@U) T@U) -(declare-fun $generated@@310 (T@U) T@U) -(declare-fun $generated@@318 (T@T T@T T@T T@U T@U T@U) T@U) -(declare-fun $generated@@319 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@320 (T@T T@T T@T T@U T@U T@U T@U) T@U) -(declare-fun $generated@@365 (T@U T@U T@U Bool) T@U) -(declare-fun $generated@@373 (T@U) T@U) -(declare-fun $generated@@375 (T@U) T@U) -(declare-fun $generated@@377 (T@U) T@U) -(declare-fun $generated@@382 (T@U) Int) -(declare-fun $generated@@408 (T@U) T@U) -(declare-fun $generated@@423 (T@T) T@U) -(declare-fun $generated@@426 (T@U) T@U) -(declare-fun $generated@@489 (T@U) T@U) -(declare-fun $generated@@493 (T@U) T@U) -(declare-fun $generated@@497 (T@U Bool) T@U) +(declare-fun $generated@@298 (T@U) T@U) +(declare-fun $generated@@303 (T@U) Int) +(declare-fun $generated@@311 (T@U) T@U) +(declare-fun $generated@@325 () T@U) +(declare-fun $generated@@327 (T@U T@U T@U Bool) T@U) +(declare-fun $generated@@334 (T@U) T@U) +(declare-fun $generated@@409 (T@U) T@U) +(declare-fun $generated@@413 (T@U) T@U) +(declare-fun $generated@@417 (T@U Bool) T@U) (assert (and (and (and (and (and (and (and (and (= ($generated@@14 $generated@@15) 0) (= ($generated@@14 $generated@@16) 1)) (= ($generated@@14 $generated@@17) 2)) (forall (($generated@@24 Bool) ) (! (= ($generated@@19 ($generated@@18 $generated@@24)) $generated@@24) :pattern ( ($generated@@18 $generated@@24)) ))) (forall (($generated@@25 T@U) ) (! (= ($generated@@18 ($generated@@19 $generated@@25)) $generated@@25) @@ -1599,347 +1556,330 @@ $generated@@337))))))))) ))) (forall (($generated@@66 T@T) ($generated@@67 T@T) ) (! (= ($generated@@50 ($generated@@46 $generated@@66 $generated@@67)) $generated@@67) :pattern ( ($generated@@46 $generated@@66 $generated@@67)) ))) (= ($generated@@14 $generated@@47) 6))) -(assert (=> (<= 0 $generated@@30) (forall (($generated@@68 T@U) ($generated@@69 T@U) ($generated@@70 T@U) ($generated@@71 T@U) ) (! (=> (or ($generated@@35 $generated@@68 $generated@@69 ($generated@@32 $generated@@33 $generated@@71)) (and (< 0 $generated@@30) (and ($generated@@34 $generated@@70) (and ($generated@@36 $generated@@33 $generated@@71 ($generated@@37 $generated@@68 $generated@@69)) ($generated@@38 $generated@@33 $generated@@71 ($generated@@37 $generated@@68 $generated@@69) $generated@@70))))) (and (forall (($generated@@72 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@72 $generated@@68) (and ($generated@@45 ($generated@@32 $generated@@33 $generated@@71)) (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 ($generated@@32 $generated@@33 $generated@@71))) $generated@@72)) (and ($generated@@45 ($generated@@32 $generated@@33 $generated@@71)) true)))) +(assert (=> (<= 0 $generated@@30) (forall (($generated@@68 T@U) ($generated@@69 T@U) ($generated@@70 T@U) ($generated@@71 T@U) ) (! (=> (or ($generated@@35 $generated@@68 $generated@@69 ($generated@@32 $generated@@33 $generated@@71)) (and (< 0 $generated@@30) (and ($generated@@34 $generated@@70) (and ($generated@@36 $generated@@33 $generated@@71 ($generated@@37 $generated@@68 $generated@@69)) ($generated@@38 $generated@@33 $generated@@71 ($generated@@37 $generated@@68 $generated@@69) $generated@@70))))) (and (forall (($generated@@72 T@U) ) (! (=> ($generated@@44 $generated@@72 $generated@@68) (and ($generated@@45 ($generated@@32 $generated@@33 $generated@@71)) (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 ($generated@@32 $generated@@33 $generated@@71))) $generated@@72)) (and ($generated@@45 ($generated@@32 $generated@@33 $generated@@71)) true)))) :pattern ( ($generated@@39 $generated@@68 $generated@@69 $generated@@70 ($generated@@40 $generated@@71) $generated@@72)) :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@71) $generated@@72)) -)) (= ($generated@@31 $generated@@68 $generated@@69 ($generated@@32 $generated@@33 $generated@@71)) (forall (($generated@@73 T@U) ) (! (=> (and ($generated@@44 $generated@@42 $generated@@73 $generated@@68) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 ($generated@@32 $generated@@33 $generated@@71))) $generated@@73))) ($generated@@39 $generated@@68 $generated@@69 $generated@@70 ($generated@@32 $generated@@47 ($generated@@40 ($generated@@32 $generated@@33 $generated@@71))) $generated@@73)) +)) (= ($generated@@31 $generated@@68 $generated@@69 ($generated@@32 $generated@@33 $generated@@71)) (forall (($generated@@73 T@U) ) (! (=> (and ($generated@@44 $generated@@73 $generated@@68) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 ($generated@@32 $generated@@33 $generated@@71))) $generated@@73))) ($generated@@39 $generated@@68 $generated@@69 $generated@@70 ($generated@@32 $generated@@47 ($generated@@40 ($generated@@32 $generated@@33 $generated@@71))) $generated@@73)) :pattern ( ($generated@@39 $generated@@68 $generated@@69 $generated@@70 ($generated@@40 $generated@@71) $generated@@73)) :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@71) $generated@@73)) ))))) :weight 3 :pattern ( ($generated@@31 $generated@@68 $generated@@69 ($generated@@32 $generated@@33 $generated@@71)) ($generated@@34 $generated@@70)) )))) -(assert (and (and (and (and (forall (($generated@@81 T@T) ($generated@@82 T@T) ($generated@@83 T@U) ($generated@@84 T@U) ($generated@@85 T@U) ) (! (= ($generated@@76 $generated@@81 $generated@@82 ($generated@@79 $generated@@81 $generated@@82 $generated@@84 $generated@@85 $generated@@83) $generated@@85) $generated@@83) - :weight 0 -)) (and (forall (($generated@@86 T@T) ($generated@@87 T@T) ($generated@@88 T@T) ($generated@@89 T@U) ($generated@@90 T@U) ($generated@@91 T@U) ($generated@@92 T@U) ) (! (or (= $generated@@87 $generated@@88) (= ($generated@@76 $generated@@88 $generated@@86 ($generated@@79 $generated@@87 $generated@@86 $generated@@90 $generated@@91 $generated@@89) $generated@@92) ($generated@@76 $generated@@88 $generated@@86 $generated@@90 $generated@@92))) - :weight 0 -)) (forall (($generated@@93 T@T) ($generated@@94 T@T) ($generated@@95 T@T) ($generated@@96 T@U) ($generated@@97 T@U) ($generated@@98 T@U) ($generated@@99 T@U) ) (! (or (= $generated@@98 $generated@@99) (= ($generated@@76 $generated@@95 $generated@@93 ($generated@@79 $generated@@94 $generated@@93 $generated@@97 $generated@@98 $generated@@96) $generated@@99) ($generated@@76 $generated@@95 $generated@@93 $generated@@97 $generated@@99))) - :weight 0 -)))) (= ($generated@@14 $generated@@77) 7)) (forall (($generated@@100 T@T) ) (= ($generated@@14 ($generated@@78 $generated@@100)) 8))) (forall (($generated@@101 T@T) ) (! (= ($generated@@80 ($generated@@78 $generated@@101)) $generated@@101) - :pattern ( ($generated@@78 $generated@@101)) +(assert (=> (<= 0 $generated@@30) (forall (($generated@@74 T@U) ($generated@@75 T@U) ($generated@@76 T@U) ) (! (=> (or ($generated@@35 $generated@@74 $generated@@75 $generated@@76) (and (< 0 $generated@@30) ($generated@@36 $generated@@33 $generated@@76 ($generated@@37 $generated@@74 $generated@@75)))) true) + :pattern ( ($generated@@31 $generated@@74 $generated@@75 $generated@@76)) )))) -(assert (forall (($generated@@102 T@U) ($generated@@103 T@U) ) (! (=> ($generated@@74 $generated@@102 $generated@@103) (forall (($generated@@104 T@U) ) (! (=> ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@102 $generated@@104) $generated@@1))) ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@103 $generated@@104) $generated@@1)))) - :pattern ( ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@103 $generated@@104) $generated@@1))) +(assert (forall (($generated@@77 T@U) ($generated@@78 T@U) ($generated@@79 T@U) ) (! (=> ($generated@@36 $generated@@33 $generated@@79 ($generated@@37 $generated@@77 $generated@@78)) ($generated@@45 $generated@@79)) + :pattern ( ($generated@@45 $generated@@79) ($generated@@36 $generated@@33 $generated@@79 ($generated@@37 $generated@@77 $generated@@78))) ))) - :pattern ( ($generated@@74 $generated@@102 $generated@@103)) +(assert (= ($generated@@80 $generated@@81) $generated@@5)) +(assert (forall (($generated@@83 T@U) ($generated@@84 T@U) ($generated@@85 T@U) ($generated@@86 T@U) ($generated@@87 T@U) ) (! (=> (and (and ($generated@@36 $generated@@47 $generated@@83 ($generated@@82 $generated@@84 $generated@@85)) (forall (($generated@@88 T@U) ) (! (=> ($generated@@44 $generated@@88 $generated@@86) ($generated@@44 $generated@@88 $generated@@84)) + :pattern ( ($generated@@44 $generated@@88 $generated@@86)) + :pattern ( ($generated@@44 $generated@@88 $generated@@84)) +))) (forall (($generated@@89 T@U) ) (! (=> ($generated@@44 $generated@@89 $generated@@85) ($generated@@44 $generated@@89 $generated@@87)) + :pattern ( ($generated@@44 $generated@@89 $generated@@85)) + :pattern ( ($generated@@44 $generated@@89 $generated@@87)) +))) ($generated@@36 $generated@@47 $generated@@83 ($generated@@82 $generated@@86 $generated@@87))) + :pattern ( ($generated@@36 $generated@@47 $generated@@83 ($generated@@82 $generated@@84 $generated@@85)) ($generated@@36 $generated@@47 $generated@@83 ($generated@@82 $generated@@86 $generated@@87))) ))) -(assert (=> (<= 0 $generated@@30) (forall (($generated@@105 T@U) ($generated@@106 T@U) ($generated@@107 T@U) ) (! (=> (or ($generated@@35 $generated@@105 $generated@@106 $generated@@107) (and (< 0 $generated@@30) ($generated@@36 $generated@@33 $generated@@107 ($generated@@37 $generated@@105 $generated@@106)))) true) - :pattern ( ($generated@@31 $generated@@105 $generated@@106 $generated@@107)) -)))) -(assert (forall (($generated@@110 T@U) ($generated@@111 T@U) ) (! (= ($generated@@38 $generated@@77 $generated@@110 $generated@@108 $generated@@111) (or (= $generated@@110 $generated@@109) ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@111 $generated@@110) $generated@@1))))) - :pattern ( ($generated@@38 $generated@@77 $generated@@110 $generated@@108 $generated@@111)) +(assert ($generated@@36 $generated@@33 $generated@@81 $generated@@90)) +(assert (and (= ($generated@@14 $generated@@91) 7) (= ($generated@@14 $generated@@95) 8))) +(assert (forall (($generated@@96 T@U) ($generated@@97 T@U) ) (! (= ($generated@@38 $generated@@91 $generated@@96 $generated@@92 $generated@@97) (or (= $generated@@96 $generated@@93) ($generated@@19 ($generated@@94 $generated@@15 ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@97 $generated@@96) $generated@@1))))) + :pattern ( ($generated@@38 $generated@@91 $generated@@96 $generated@@92 $generated@@97)) +))) +(assert (forall (($generated@@99 T@U) ($generated@@100 T@U) ($generated@@101 T@U) ($generated@@102 T@U) ) (! (=> (and ($generated@@34 $generated@@102) (and ($generated@@45 $generated@@99) ($generated@@38 $generated@@33 $generated@@99 ($generated@@37 $generated@@100 $generated@@101) $generated@@102))) ($generated@@38 $generated@@47 ($generated@@40 $generated@@99) ($generated@@98 $generated@@100 $generated@@101) $generated@@102)) + :pattern ( ($generated@@38 $generated@@47 ($generated@@40 $generated@@99) ($generated@@98 $generated@@100 $generated@@101) $generated@@102)) ))) -(assert (forall (($generated@@112 T@U) ($generated@@113 T@U) ($generated@@114 T@U) ) (! (=> ($generated@@36 $generated@@33 $generated@@114 ($generated@@37 $generated@@112 $generated@@113)) ($generated@@45 $generated@@114)) - :pattern ( ($generated@@45 $generated@@114) ($generated@@36 $generated@@33 $generated@@114 ($generated@@37 $generated@@112 $generated@@113))) +(assert (forall (($generated@@104 T@U) ($generated@@105 T@U) ) (! (=> ($generated@@103 $generated@@104 $generated@@105) (forall (($generated@@106 T@U) ) (! (=> ($generated@@19 ($generated@@94 $generated@@15 ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@104 $generated@@106) $generated@@1))) ($generated@@19 ($generated@@94 $generated@@15 ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@105 $generated@@106) $generated@@1)))) + :pattern ( ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@105 $generated@@106) $generated@@1)) ))) -(assert (= ($generated@@115 $generated@@116) $generated@@5)) -(assert (forall (($generated@@118 T@U) ($generated@@119 T@U) ($generated@@120 T@U) ($generated@@121 T@U) ($generated@@122 T@U) ) (! (=> (and (and ($generated@@36 $generated@@47 $generated@@118 ($generated@@117 $generated@@119 $generated@@120)) (forall (($generated@@123 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@123 $generated@@121) ($generated@@44 $generated@@42 $generated@@123 $generated@@119)) - :pattern ( ($generated@@44 $generated@@42 $generated@@123 $generated@@121)) - :pattern ( ($generated@@44 $generated@@42 $generated@@123 $generated@@119)) -))) (forall (($generated@@124 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@124 $generated@@120) ($generated@@44 $generated@@42 $generated@@124 $generated@@122)) - :pattern ( ($generated@@44 $generated@@42 $generated@@124 $generated@@120)) - :pattern ( ($generated@@44 $generated@@42 $generated@@124 $generated@@122)) -))) ($generated@@36 $generated@@47 $generated@@118 ($generated@@117 $generated@@121 $generated@@122))) - :pattern ( ($generated@@36 $generated@@47 $generated@@118 ($generated@@117 $generated@@119 $generated@@120)) ($generated@@36 $generated@@47 $generated@@118 ($generated@@117 $generated@@121 $generated@@122))) + :pattern ( ($generated@@103 $generated@@104 $generated@@105)) ))) -(assert ($generated@@36 $generated@@33 $generated@@116 $generated@@125)) -(assert (forall (($generated@@127 T@U) ($generated@@128 T@U) ($generated@@129 T@U) ($generated@@130 T@U) ) (! (=> (and ($generated@@34 $generated@@130) (and ($generated@@45 $generated@@127) ($generated@@38 $generated@@33 $generated@@127 ($generated@@37 $generated@@128 $generated@@129) $generated@@130))) ($generated@@38 $generated@@47 ($generated@@40 $generated@@127) ($generated@@126 $generated@@128 $generated@@129) $generated@@130)) - :pattern ( ($generated@@38 $generated@@47 ($generated@@40 $generated@@127) ($generated@@126 $generated@@128 $generated@@129) $generated@@130)) +(assert (forall (($generated@@108 T@U) ($generated@@109 T@U) ) (! (= ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@108 ($generated@@107 $generated@@109)) (forall (($generated@@110 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@108 $generated@@110)) ($generated@@44 $generated@@110 $generated@@109)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@108 $generated@@110)) ))) -(assert (forall (($generated@@132 T@U) ($generated@@133 T@U) ) (! (= ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@132 ($generated@@131 $generated@@133)) (forall (($generated@@134 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@132 $generated@@134)) ($generated@@44 $generated@@42 $generated@@134 $generated@@133)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@132 $generated@@134)) + :pattern ( ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@108 ($generated@@107 $generated@@109))) ))) - :pattern ( ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@132 ($generated@@131 $generated@@133))) +(assert (forall (($generated@@112 T@U) ($generated@@113 T@U) ) (! (= ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@112 ($generated@@111 $generated@@113)) (forall (($generated@@114 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@112 $generated@@114)) ($generated@@44 $generated@@114 $generated@@113)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@112 $generated@@114)) ))) -(assert (forall (($generated@@136 T@U) ($generated@@137 T@U) ) (! (= ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@136 ($generated@@135 $generated@@137)) (forall (($generated@@138 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@136 $generated@@138)) ($generated@@44 $generated@@42 $generated@@138 $generated@@137)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@136 $generated@@138)) + :pattern ( ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@112 ($generated@@111 $generated@@113))) ))) - :pattern ( ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@136 ($generated@@135 $generated@@137))) +(assert (forall (($generated@@115 T@U) ($generated@@116 T@T) ) (! (= ($generated@@32 $generated@@116 $generated@@115) $generated@@115) + :pattern ( ($generated@@32 $generated@@116 $generated@@115)) ))) -(assert (forall (($generated@@139 T@U) ($generated@@140 T@T) ) (! (= ($generated@@32 $generated@@140 $generated@@139) $generated@@139) - :pattern ( ($generated@@32 $generated@@140 $generated@@139)) +(assert (forall (($generated@@121 T@U) ($generated@@122 T@U) ($generated@@123 T@U) ($generated@@124 T@U) ($generated@@125 T@U) ) (! (=> (and ($generated@@34 $generated@@123) (and ($generated@@44 $generated@@125 $generated@@121) ($generated@@36 $generated@@47 $generated@@124 ($generated@@82 $generated@@121 $generated@@122)))) (= ($generated@@119 ($generated@@117 $generated@@121 $generated@@122 $generated@@118 $generated@@124 $generated@@125) $generated@@120) ($generated@@119 ($generated@@117 $generated@@121 $generated@@122 $generated@@123 $generated@@124 $generated@@125) $generated@@120))) + :pattern ( ($generated@@117 $generated@@121 $generated@@122 $generated@@118 $generated@@124 $generated@@125) ($generated@@34 $generated@@123)) + :pattern ( ($generated@@117 $generated@@121 $generated@@122 $generated@@123 $generated@@124 $generated@@125)) ))) -(assert (forall (($generated@@145 T@U) ($generated@@146 T@U) ($generated@@147 T@U) ($generated@@148 T@U) ($generated@@149 T@U) ) (! (=> (and ($generated@@34 $generated@@147) (and ($generated@@44 $generated@@42 $generated@@149 $generated@@145) ($generated@@36 $generated@@47 $generated@@148 ($generated@@117 $generated@@145 $generated@@146)))) (= ($generated@@143 $generated@@42 ($generated@@141 $generated@@145 $generated@@146 $generated@@142 $generated@@148 $generated@@149) ($generated@@144 $generated@@42)) ($generated@@143 $generated@@42 ($generated@@141 $generated@@145 $generated@@146 $generated@@147 $generated@@148 $generated@@149) ($generated@@144 $generated@@42)))) - :pattern ( ($generated@@141 $generated@@145 $generated@@146 $generated@@142 $generated@@148 $generated@@149) ($generated@@34 $generated@@147)) - :pattern ( ($generated@@141 $generated@@145 $generated@@146 $generated@@147 $generated@@148 $generated@@149)) +(assert (forall (($generated@@127 T@U) ($generated@@128 T@U) ($generated@@129 T@U) ($generated@@130 T@U) ) (! (= ($generated@@36 $generated@@33 ($generated@@126 $generated@@129 $generated@@130) ($generated@@37 $generated@@127 $generated@@128)) (and ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@129 ($generated@@111 $generated@@127)) ($generated@@36 $generated@@47 $generated@@130 ($generated@@98 $generated@@127 $generated@@128)))) + :pattern ( ($generated@@36 $generated@@33 ($generated@@126 $generated@@129 $generated@@130) ($generated@@37 $generated@@127 $generated@@128))) ))) -(assert (forall (($generated@@151 T@U) ($generated@@152 T@U) ($generated@@153 T@U) ($generated@@154 T@U) ) (! (= ($generated@@36 $generated@@33 ($generated@@150 $generated@@153 $generated@@154) ($generated@@37 $generated@@151 $generated@@152)) (and ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) $generated@@153 ($generated@@135 $generated@@151)) ($generated@@36 $generated@@47 $generated@@154 ($generated@@126 $generated@@151 $generated@@152)))) - :pattern ( ($generated@@36 $generated@@33 ($generated@@150 $generated@@153 $generated@@154) ($generated@@37 $generated@@151 $generated@@152))) +(assert (forall (($generated@@131 T@U) ) (! (= ($generated@@45 $generated@@131) (= ($generated@@80 $generated@@131) $generated@@7)) + :pattern ( ($generated@@45 $generated@@131)) ))) -(assert (forall (($generated@@155 T@U) ) (! (= ($generated@@45 $generated@@155) (= ($generated@@115 $generated@@155) $generated@@7)) - :pattern ( ($generated@@45 $generated@@155)) +(assert (forall (($generated@@133 T@U) ($generated@@134 T@T) ) (! (= ($generated@@132 $generated@@134 ($generated@@94 $generated@@134 $generated@@133)) $generated@@133) + :pattern ( ($generated@@94 $generated@@134 $generated@@133)) ))) -(assert (forall (($generated@@156 T@U) ) (! (=> ($generated@@45 $generated@@156) (exists (($generated@@157 T@U) ($generated@@158 T@U) ) (= $generated@@156 ($generated@@150 $generated@@157 $generated@@158)))) - :pattern ( ($generated@@45 $generated@@156)) +(assert (forall (($generated@@135 T@U) ) (! (=> ($generated@@45 $generated@@135) (exists (($generated@@136 T@U) ($generated@@137 T@U) ) (= $generated@@135 ($generated@@126 $generated@@136 $generated@@137)))) + :pattern ( ($generated@@45 $generated@@135)) ))) -(assert (forall (($generated@@160 T@U) ($generated@@161 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@159 $generated@@160) $generated@@161)) ($generated@@19 ($generated@@41 $generated@@77 $generated@@15 $generated@@160 ($generated@@75 $generated@@77 $generated@@161)))) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@159 $generated@@160) $generated@@161)) +(assert (forall (($generated@@139 T@U) ($generated@@140 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@138 $generated@@139) $generated@@140)) ($generated@@19 ($generated@@41 $generated@@91 $generated@@15 $generated@@139 ($generated@@94 $generated@@91 $generated@@140)))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@138 $generated@@139) $generated@@140)) ))) -(assert (= ($generated@@14 $generated@@163) 9)) -(assert (forall (($generated@@164 T@U) ($generated@@165 T@U) ($generated@@166 T@T) ) (! (= ($generated@@162 $generated@@166 $generated@@164 $generated@@165) ($generated@@41 $generated@@163 $generated@@166 $generated@@164 $generated@@165)) - :pattern ( ($generated@@162 $generated@@166 $generated@@164 $generated@@165)) +(assert (= ($generated@@14 $generated@@142) 9)) +(assert (forall (($generated@@143 T@U) ($generated@@144 T@U) ($generated@@145 T@T) ) (! (= ($generated@@141 $generated@@145 $generated@@143 $generated@@144) ($generated@@41 $generated@@142 $generated@@145 $generated@@143 $generated@@144)) + :pattern ( ($generated@@141 $generated@@145 $generated@@143 $generated@@144)) ))) -(assert (forall (($generated@@167 T@U) ($generated@@168 T@U) ($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@U) ) (! (=> ($generated@@34 $generated@@171) (= ($generated@@38 $generated@@33 ($generated@@150 $generated@@169 $generated@@170) ($generated@@37 $generated@@167 $generated@@168) $generated@@171) (and ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@169 ($generated@@135 $generated@@167) $generated@@171) ($generated@@38 $generated@@47 $generated@@170 ($generated@@126 $generated@@167 $generated@@168) $generated@@171)))) - :pattern ( ($generated@@38 $generated@@33 ($generated@@150 $generated@@169 $generated@@170) ($generated@@37 $generated@@167 $generated@@168) $generated@@171)) +(assert (forall (($generated@@146 T@U) ($generated@@147 T@U) ($generated@@148 T@U) ($generated@@149 T@U) ($generated@@150 T@U) ) (! (=> ($generated@@34 $generated@@150) (= ($generated@@38 $generated@@33 ($generated@@126 $generated@@148 $generated@@149) ($generated@@37 $generated@@146 $generated@@147) $generated@@150) (and ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@148 ($generated@@111 $generated@@146) $generated@@150) ($generated@@38 $generated@@47 $generated@@149 ($generated@@98 $generated@@146 $generated@@147) $generated@@150)))) + :pattern ( ($generated@@38 $generated@@33 ($generated@@126 $generated@@148 $generated@@149) ($generated@@37 $generated@@146 $generated@@147) $generated@@150)) ))) -(assert ($generated@@34 $generated@@142)) -(assert (forall (($generated@@174 T@U) ($generated@@175 T@U) ($generated@@176 T@U) ($generated@@177 T@T) ) (! (= ($generated@@172 $generated@@42 ($generated@@173 $generated@@177 $generated@@174) $generated@@175 $generated@@176) ($generated@@38 $generated@@177 $generated@@174 $generated@@175 $generated@@176)) - :pattern ( ($generated@@172 $generated@@42 ($generated@@173 $generated@@177 $generated@@174) $generated@@175 $generated@@176)) +(assert ($generated@@34 $generated@@118)) +(assert (forall (($generated@@152 T@U) ($generated@@153 T@U) ($generated@@154 T@U) ($generated@@155 T@T) ) (! (= ($generated@@151 ($generated@@132 $generated@@155 $generated@@152) $generated@@153 $generated@@154) ($generated@@38 $generated@@155 $generated@@152 $generated@@153 $generated@@154)) + :pattern ( ($generated@@151 ($generated@@132 $generated@@155 $generated@@152) $generated@@153 $generated@@154)) ))) -(assert (forall (($generated@@178 T@U) ($generated@@179 T@U) ($generated@@180 T@U) ($generated@@181 T@U) ) (! (=> ($generated@@74 $generated@@178 $generated@@179) (=> ($generated@@172 $generated@@42 $generated@@180 $generated@@181 $generated@@178) ($generated@@172 $generated@@42 $generated@@180 $generated@@181 $generated@@179))) - :pattern ( ($generated@@74 $generated@@178 $generated@@179) ($generated@@172 $generated@@42 $generated@@180 $generated@@181 $generated@@178)) +(assert (forall (($generated@@156 T@U) ($generated@@157 T@U) ($generated@@158 T@U) ($generated@@159 T@U) ) (! (=> ($generated@@103 $generated@@156 $generated@@157) (=> ($generated@@151 $generated@@158 $generated@@159 $generated@@156) ($generated@@151 $generated@@158 $generated@@159 $generated@@157))) + :pattern ( ($generated@@103 $generated@@156 $generated@@157) ($generated@@151 $generated@@158 $generated@@159 $generated@@156)) ))) -(assert (forall (($generated@@182 T@U) ($generated@@183 T@U) ($generated@@184 T@U) ($generated@@185 T@U) ($generated@@186 T@T) ) (! (=> ($generated@@74 $generated@@182 $generated@@183) (=> ($generated@@38 $generated@@186 $generated@@184 $generated@@185 $generated@@182) ($generated@@38 $generated@@186 $generated@@184 $generated@@185 $generated@@183))) - :pattern ( ($generated@@74 $generated@@182 $generated@@183) ($generated@@38 $generated@@186 $generated@@184 $generated@@185 $generated@@182)) +(assert (forall (($generated@@160 T@U) ($generated@@161 T@U) ($generated@@162 T@U) ($generated@@163 T@U) ($generated@@164 T@T) ) (! (=> ($generated@@103 $generated@@160 $generated@@161) (=> ($generated@@38 $generated@@164 $generated@@162 $generated@@163 $generated@@160) ($generated@@38 $generated@@164 $generated@@162 $generated@@163 $generated@@161))) + :pattern ( ($generated@@103 $generated@@160 $generated@@161) ($generated@@38 $generated@@164 $generated@@162 $generated@@163 $generated@@160)) ))) -(assert (forall (($generated@@187 T@U) ($generated@@188 T@U) ($generated@@189 T@T) ) (! (= ($generated@@143 $generated@@189 $generated@@187 $generated@@188) (forall (($generated@@190 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@189 $generated@@15 $generated@@187 $generated@@190)) ($generated@@19 ($generated@@41 $generated@@189 $generated@@15 $generated@@188 $generated@@190))) - :pattern ( ($generated@@41 $generated@@189 $generated@@15 $generated@@187 $generated@@190)) - :pattern ( ($generated@@41 $generated@@189 $generated@@15 $generated@@188 $generated@@190)) +(assert (forall (($generated@@165 T@U) ($generated@@166 T@U) ) (! (= ($generated@@119 $generated@@165 $generated@@166) (forall (($generated@@167 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@165 $generated@@167)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@166 $generated@@167))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@165 $generated@@167)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@166 $generated@@167)) ))) - :pattern ( ($generated@@143 $generated@@189 $generated@@187 $generated@@188)) + :pattern ( ($generated@@119 $generated@@165 $generated@@166)) ))) -(assert (forall (($generated@@191 T@U) ($generated@@192 T@U) ($generated@@193 T@U) ($generated@@194 T@U) ) (! (= ($generated@@38 $generated@@47 $generated@@193 ($generated@@126 $generated@@191 $generated@@192) $generated@@194) ($generated@@38 $generated@@47 $generated@@193 ($generated@@117 $generated@@191 $generated@@192) $generated@@194)) - :pattern ( ($generated@@38 $generated@@47 $generated@@193 ($generated@@126 $generated@@191 $generated@@192) $generated@@194)) +(assert (forall (($generated@@168 T@U) ($generated@@169 T@U) ($generated@@170 T@U) ($generated@@171 T@U) ) (! (= ($generated@@38 $generated@@47 $generated@@170 ($generated@@98 $generated@@168 $generated@@169) $generated@@171) ($generated@@38 $generated@@47 $generated@@170 ($generated@@82 $generated@@168 $generated@@169) $generated@@171)) + :pattern ( ($generated@@38 $generated@@47 $generated@@170 ($generated@@98 $generated@@168 $generated@@169) $generated@@171)) ))) -(assert (and (forall (($generated@@199 T@T) ($generated@@200 T@T) ($generated@@201 T@T) ($generated@@202 T@U) ($generated@@203 T@U) ($generated@@204 T@U) ($generated@@205 T@U) ) (! (= ($generated@@197 $generated@@199 $generated@@200 $generated@@201 ($generated@@198 $generated@@199 $generated@@200 $generated@@201 $generated@@203 $generated@@204 $generated@@205 $generated@@202) $generated@@204 $generated@@205) $generated@@202) +(assert (and (forall (($generated@@176 T@T) ($generated@@177 T@T) ($generated@@178 T@T) ($generated@@179 T@U) ($generated@@180 T@U) ($generated@@181 T@U) ($generated@@182 T@U) ) (! (= ($generated@@174 $generated@@176 $generated@@177 $generated@@178 ($generated@@175 $generated@@176 $generated@@177 $generated@@178 $generated@@180 $generated@@181 $generated@@182 $generated@@179) $generated@@181 $generated@@182) $generated@@179) :weight 0 -)) (and (forall (($generated@@206 T@T) ($generated@@207 T@T) ($generated@@208 T@T) ($generated@@209 T@U) ($generated@@210 T@U) ($generated@@211 T@U) ($generated@@212 T@U) ($generated@@213 T@U) ($generated@@214 T@U) ) (! (or (= $generated@@211 $generated@@213) (= ($generated@@197 $generated@@206 $generated@@207 $generated@@208 ($generated@@198 $generated@@206 $generated@@207 $generated@@208 $generated@@210 $generated@@211 $generated@@212 $generated@@209) $generated@@213 $generated@@214) ($generated@@197 $generated@@206 $generated@@207 $generated@@208 $generated@@210 $generated@@213 $generated@@214))) +)) (and (forall (($generated@@183 T@T) ($generated@@184 T@T) ($generated@@185 T@T) ($generated@@186 T@U) ($generated@@187 T@U) ($generated@@188 T@U) ($generated@@189 T@U) ($generated@@190 T@U) ($generated@@191 T@U) ) (! (or (= $generated@@188 $generated@@190) (= ($generated@@174 $generated@@183 $generated@@184 $generated@@185 ($generated@@175 $generated@@183 $generated@@184 $generated@@185 $generated@@187 $generated@@188 $generated@@189 $generated@@186) $generated@@190 $generated@@191) ($generated@@174 $generated@@183 $generated@@184 $generated@@185 $generated@@187 $generated@@190 $generated@@191))) :weight 0 -)) (forall (($generated@@215 T@T) ($generated@@216 T@T) ($generated@@217 T@T) ($generated@@218 T@U) ($generated@@219 T@U) ($generated@@220 T@U) ($generated@@221 T@U) ($generated@@222 T@U) ($generated@@223 T@U) ) (! (or (= $generated@@221 $generated@@223) (= ($generated@@197 $generated@@215 $generated@@216 $generated@@217 ($generated@@198 $generated@@215 $generated@@216 $generated@@217 $generated@@219 $generated@@220 $generated@@221 $generated@@218) $generated@@222 $generated@@223) ($generated@@197 $generated@@215 $generated@@216 $generated@@217 $generated@@219 $generated@@222 $generated@@223))) +)) (forall (($generated@@192 T@T) ($generated@@193 T@T) ($generated@@194 T@T) ($generated@@195 T@U) ($generated@@196 T@U) ($generated@@197 T@U) ($generated@@198 T@U) ($generated@@199 T@U) ($generated@@200 T@U) ) (! (or (= $generated@@198 $generated@@200) (= ($generated@@174 $generated@@192 $generated@@193 $generated@@194 ($generated@@175 $generated@@192 $generated@@193 $generated@@194 $generated@@196 $generated@@197 $generated@@198 $generated@@195) $generated@@199 $generated@@200) ($generated@@174 $generated@@192 $generated@@193 $generated@@194 $generated@@196 $generated@@199 $generated@@200))) :weight 0 ))))) -(assert (forall (($generated@@224 T@U) ($generated@@225 T@U) ($generated@@226 T@U) ($generated@@227 T@U) ($generated@@228 T@U) ($generated@@229 T@U) ($generated@@230 T@U) ) (! (= ($generated@@195 $generated@@224 $generated@@225 $generated@@226 ($generated@@196 $generated@@227 $generated@@228 $generated@@229) $generated@@230) ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@42 $generated@@227 $generated@@226 $generated@@230)) - :pattern ( ($generated@@195 $generated@@224 $generated@@225 $generated@@226 ($generated@@196 $generated@@227 $generated@@228 $generated@@229) $generated@@230)) +(assert (forall (($generated@@201 T@U) ($generated@@202 T@U) ($generated@@203 T@U) ($generated@@204 T@U) ($generated@@205 T@U) ($generated@@206 T@U) ($generated@@207 T@U) ) (! (= ($generated@@172 $generated@@201 $generated@@202 $generated@@203 ($generated@@173 $generated@@204 $generated@@205 $generated@@206) $generated@@207) ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@42 $generated@@204 $generated@@203 $generated@@207)) + :pattern ( ($generated@@172 $generated@@201 $generated@@202 $generated@@203 ($generated@@173 $generated@@204 $generated@@205 $generated@@206) $generated@@207)) ))) -(assert (forall (($generated@@231 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@231 $generated@@108) (and (= ($generated@@173 $generated@@77 ($generated@@75 $generated@@77 $generated@@231)) $generated@@231) ($generated@@36 $generated@@77 ($generated@@75 $generated@@77 $generated@@231) $generated@@108))) - :pattern ( ($generated@@44 $generated@@42 $generated@@231 $generated@@108)) +(assert (forall (($generated@@208 T@U) ) (! (=> ($generated@@44 $generated@@208 $generated@@92) (and (= ($generated@@132 $generated@@91 ($generated@@94 $generated@@91 $generated@@208)) $generated@@208) ($generated@@36 $generated@@91 ($generated@@94 $generated@@91 $generated@@208) $generated@@92))) + :pattern ( ($generated@@44 $generated@@208 $generated@@92)) ))) -(assert (forall (($generated@@232 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@232 $generated@@125) (and (= ($generated@@173 $generated@@33 ($generated@@75 $generated@@33 $generated@@232)) $generated@@232) ($generated@@36 $generated@@33 ($generated@@75 $generated@@33 $generated@@232) $generated@@125))) - :pattern ( ($generated@@44 $generated@@42 $generated@@232 $generated@@125)) +(assert (forall (($generated@@209 T@U) ) (! (=> ($generated@@44 $generated@@209 $generated@@90) (and (= ($generated@@132 $generated@@33 ($generated@@94 $generated@@33 $generated@@209)) $generated@@209) ($generated@@36 $generated@@33 ($generated@@94 $generated@@33 $generated@@209) $generated@@90))) + :pattern ( ($generated@@44 $generated@@209 $generated@@90)) ))) -(assert (forall (($generated@@233 T@U) ($generated@@234 T@U) ($generated@@235 T@U) ($generated@@236 T@U) ) (! (=> (and ($generated@@34 $generated@@236) ($generated@@38 $generated@@47 $generated@@233 ($generated@@117 $generated@@234 $generated@@235) $generated@@236)) (forall (($generated@@237 T@U) ) (! (=> (and ($generated@@172 $generated@@42 $generated@@237 $generated@@234 $generated@@236) ($generated@@39 $generated@@234 $generated@@235 $generated@@236 $generated@@233 $generated@@237)) ($generated@@172 $generated@@42 ($generated@@195 $generated@@234 $generated@@235 $generated@@236 $generated@@233 $generated@@237) $generated@@235 $generated@@236)) - :pattern ( ($generated@@195 $generated@@234 $generated@@235 $generated@@236 $generated@@233 $generated@@237)) +(assert (forall (($generated@@210 T@U) ($generated@@211 T@U) ($generated@@212 T@U) ($generated@@213 T@U) ) (! (=> (and ($generated@@34 $generated@@213) ($generated@@38 $generated@@47 $generated@@210 ($generated@@82 $generated@@211 $generated@@212) $generated@@213)) (forall (($generated@@214 T@U) ) (! (=> (and ($generated@@151 $generated@@214 $generated@@211 $generated@@213) ($generated@@39 $generated@@211 $generated@@212 $generated@@213 $generated@@210 $generated@@214)) ($generated@@151 ($generated@@172 $generated@@211 $generated@@212 $generated@@213 $generated@@210 $generated@@214) $generated@@212 $generated@@213)) + :pattern ( ($generated@@172 $generated@@211 $generated@@212 $generated@@213 $generated@@210 $generated@@214)) ))) - :pattern ( ($generated@@38 $generated@@47 $generated@@233 ($generated@@117 $generated@@234 $generated@@235) $generated@@236)) -))) -(assert (forall (($generated@@238 T@U) ($generated@@239 T@U) ($generated@@240 T@U) ($generated@@241 T@U) ) (! (=> ($generated@@34 $generated@@241) (= ($generated@@38 $generated@@47 $generated@@238 ($generated@@117 $generated@@239 $generated@@240) $generated@@241) (forall (($generated@@242 T@U) ) (! (=> (and (and ($generated@@44 $generated@@42 $generated@@242 $generated@@239) ($generated@@172 $generated@@42 $generated@@242 $generated@@239 $generated@@241)) ($generated@@39 $generated@@239 $generated@@240 $generated@@241 $generated@@238 $generated@@242)) (forall (($generated@@243 T@U) ) (! (=> (and (or (not (= $generated@@243 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@239 $generated@@240 $generated@@241 $generated@@238 $generated@@242) ($generated@@173 $generated@@77 $generated@@243)))) ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@241 $generated@@243) $generated@@1)))) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@239 $generated@@240 $generated@@241 $generated@@238 $generated@@242) ($generated@@173 $generated@@77 $generated@@243))) -))) - :pattern ( ($generated@@195 $generated@@239 $generated@@240 $generated@@241 $generated@@238 $generated@@242)) - :pattern ( ($generated@@141 $generated@@239 $generated@@240 $generated@@241 $generated@@238 $generated@@242)) -)))) - :pattern ( ($generated@@38 $generated@@47 $generated@@238 ($generated@@117 $generated@@239 $generated@@240) $generated@@241)) + :pattern ( ($generated@@38 $generated@@47 $generated@@210 ($generated@@82 $generated@@211 $generated@@212) $generated@@213)) ))) -(assert (forall (($generated@@245 Bool) ($generated@@246 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@77 $generated@@15 ($generated@@244 $generated@@245) $generated@@246)) $generated@@245) - :pattern ( ($generated@@41 $generated@@77 $generated@@15 ($generated@@244 $generated@@245) $generated@@246)) +(assert (forall (($generated@@216 Bool) ($generated@@217 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@91 $generated@@15 ($generated@@215 $generated@@216) $generated@@217)) $generated@@216) + :pattern ( ($generated@@41 $generated@@91 $generated@@15 ($generated@@215 $generated@@216) $generated@@217)) ))) -(assert (forall (($generated@@248 T@U) ($generated@@249 T@U) ) (! (= ($generated@@41 $generated@@163 $generated@@47 ($generated@@247 $generated@@248) $generated@@249) $generated@@248) - :pattern ( ($generated@@41 $generated@@163 $generated@@47 ($generated@@247 $generated@@248) $generated@@249)) +(assert (forall (($generated@@219 T@U) ($generated@@220 T@U) ) (! (= ($generated@@41 $generated@@142 $generated@@47 ($generated@@218 $generated@@219) $generated@@220) $generated@@219) + :pattern ( ($generated@@41 $generated@@142 $generated@@47 ($generated@@218 $generated@@219) $generated@@220)) ))) -(assert (forall (($generated@@250 T@U) ($generated@@251 T@U) ($generated@@252 T@U) ) (! (= ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@250 ($generated@@131 $generated@@251) $generated@@252) (forall (($generated@@253 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@250 $generated@@253)) ($generated@@172 $generated@@42 $generated@@253 $generated@@251 $generated@@252)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@250 $generated@@253)) +(assert (forall (($generated@@221 T@U) ($generated@@222 T@U) ($generated@@223 T@U) ) (! (= ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@221 ($generated@@107 $generated@@222) $generated@@223) (forall (($generated@@224 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@221 $generated@@224)) ($generated@@151 $generated@@224 $generated@@222 $generated@@223)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@221 $generated@@224)) ))) - :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@250 ($generated@@131 $generated@@251) $generated@@252)) + :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@221 ($generated@@107 $generated@@222) $generated@@223)) ))) -(assert (forall (($generated@@254 T@U) ($generated@@255 T@U) ($generated@@256 T@U) ) (! (= ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@254 ($generated@@135 $generated@@255) $generated@@256) (forall (($generated@@257 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@254 $generated@@257)) ($generated@@172 $generated@@42 $generated@@257 $generated@@255 $generated@@256)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@254 $generated@@257)) +(assert (forall (($generated@@225 T@U) ($generated@@226 T@U) ($generated@@227 T@U) ) (! (= ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@225 ($generated@@111 $generated@@226) $generated@@227) (forall (($generated@@228 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@225 $generated@@228)) ($generated@@151 $generated@@228 $generated@@226 $generated@@227)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@225 $generated@@228)) ))) - :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@254 ($generated@@135 $generated@@255) $generated@@256)) + :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) $generated@@225 ($generated@@111 $generated@@226) $generated@@227)) ))) -(assert (forall (($generated@@258 T@U) ($generated@@259 T@U) ($generated@@260 T@U) ($generated@@261 T@U) ($generated@@262 T@U) ($generated@@263 T@U) ($generated@@264 T@U) ($generated@@265 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@258 $generated@@259 $generated@@260 ($generated@@196 $generated@@261 $generated@@262 $generated@@263) $generated@@264) $generated@@265)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) $generated@@263 $generated@@260 $generated@@264) $generated@@265))) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@258 $generated@@259 $generated@@260 ($generated@@196 $generated@@261 $generated@@262 $generated@@263) $generated@@264) $generated@@265)) +(assert (forall (($generated@@229 T@U) ($generated@@230 T@U) ($generated@@231 T@U) ($generated@@232 T@U) ($generated@@233 T@U) ($generated@@234 T@U) ($generated@@235 T@U) ($generated@@236 T@U) ) (! (= ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@229 $generated@@230 $generated@@231 ($generated@@173 $generated@@232 $generated@@233 $generated@@234) $generated@@235) $generated@@236)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) $generated@@234 $generated@@231 $generated@@235) $generated@@236))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@229 $generated@@230 $generated@@231 ($generated@@173 $generated@@232 $generated@@233 $generated@@234) $generated@@235) $generated@@236)) ))) -(assert (forall (($generated@@266 T@U) ($generated@@267 T@U) ($generated@@268 T@T) ) (! (=> ($generated@@143 $generated@@268 $generated@@266 $generated@@267) (= $generated@@266 $generated@@267)) - :pattern ( ($generated@@143 $generated@@268 $generated@@266 $generated@@267)) +(assert (forall (($generated@@237 T@U) ($generated@@238 T@U) ) (! (=> ($generated@@119 $generated@@237 $generated@@238) (= $generated@@237 $generated@@238)) + :pattern ( ($generated@@119 $generated@@237 $generated@@238)) ))) -(assert (=> (<= 0 $generated@@30) (forall (($generated@@269 T@U) ($generated@@270 T@U) ($generated@@271 T@U) ($generated@@272 T@U) ) (! (=> (or ($generated@@35 $generated@@269 $generated@@270 $generated@@272) (and (< 0 $generated@@30) (and ($generated@@34 $generated@@271) (and ($generated@@36 $generated@@33 $generated@@272 ($generated@@37 $generated@@269 $generated@@270)) ($generated@@38 $generated@@33 $generated@@272 ($generated@@37 $generated@@269 $generated@@270) $generated@@271))))) (and (forall (($generated@@273 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@273 $generated@@269) (and ($generated@@45 $generated@@272) (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@272) $generated@@273)) (and ($generated@@45 $generated@@272) true)))) - :pattern ( ($generated@@39 $generated@@269 $generated@@270 $generated@@271 ($generated@@40 $generated@@272) $generated@@273)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@272) $generated@@273)) -)) (= ($generated@@31 $generated@@269 $generated@@270 $generated@@272) (forall (($generated@@274 T@U) ) (! (=> (and ($generated@@44 $generated@@42 $generated@@274 $generated@@269) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@272) $generated@@274))) ($generated@@39 $generated@@269 $generated@@270 $generated@@271 ($generated@@40 $generated@@272) $generated@@274)) - :pattern ( ($generated@@39 $generated@@269 $generated@@270 $generated@@271 ($generated@@40 $generated@@272) $generated@@274)) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@272) $generated@@274)) +(assert (=> (<= 0 $generated@@30) (forall (($generated@@239 T@U) ($generated@@240 T@U) ($generated@@241 T@U) ($generated@@242 T@U) ) (! (=> (or ($generated@@35 $generated@@239 $generated@@240 $generated@@242) (and (< 0 $generated@@30) (and ($generated@@34 $generated@@241) (and ($generated@@36 $generated@@33 $generated@@242 ($generated@@37 $generated@@239 $generated@@240)) ($generated@@38 $generated@@33 $generated@@242 ($generated@@37 $generated@@239 $generated@@240) $generated@@241))))) (and (forall (($generated@@243 T@U) ) (! (=> ($generated@@44 $generated@@243 $generated@@239) (and ($generated@@45 $generated@@242) (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@242) $generated@@243)) (and ($generated@@45 $generated@@242) true)))) + :pattern ( ($generated@@39 $generated@@239 $generated@@240 $generated@@241 ($generated@@40 $generated@@242) $generated@@243)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@242) $generated@@243)) +)) (= ($generated@@31 $generated@@239 $generated@@240 $generated@@242) (forall (($generated@@244 T@U) ) (! (=> (and ($generated@@44 $generated@@244 $generated@@239) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@242) $generated@@244))) ($generated@@39 $generated@@239 $generated@@240 $generated@@241 ($generated@@40 $generated@@242) $generated@@244)) + :pattern ( ($generated@@39 $generated@@239 $generated@@240 $generated@@241 ($generated@@40 $generated@@242) $generated@@244)) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@43 $generated@@242) $generated@@244)) ))))) - :pattern ( ($generated@@31 $generated@@269 $generated@@270 $generated@@272) ($generated@@34 $generated@@271)) + :pattern ( ($generated@@31 $generated@@239 $generated@@240 $generated@@242) ($generated@@34 $generated@@241)) )))) -(assert (forall (($generated@@275 T@U) ($generated@@276 T@U) ($generated@@277 T@U) ) (! (=> (or (not (= $generated@@275 $generated@@277)) (not true)) (=> (and ($generated@@74 $generated@@275 $generated@@276) ($generated@@74 $generated@@276 $generated@@277)) ($generated@@74 $generated@@275 $generated@@277))) - :pattern ( ($generated@@74 $generated@@275 $generated@@276) ($generated@@74 $generated@@276 $generated@@277)) +(assert (forall (($generated@@245 T@U) ($generated@@246 T@U) ($generated@@247 T@U) ) (! (=> (or (not (= $generated@@245 $generated@@247)) (not true)) (=> (and ($generated@@103 $generated@@245 $generated@@246) ($generated@@103 $generated@@246 $generated@@247)) ($generated@@103 $generated@@245 $generated@@247))) + :pattern ( ($generated@@103 $generated@@245 $generated@@246) ($generated@@103 $generated@@246 $generated@@247)) ))) -(assert (forall (($generated@@278 T@U) ($generated@@279 T@U) ($generated@@280 T@U) ) (! (= ($generated@@36 $generated@@47 $generated@@278 ($generated@@117 $generated@@279 $generated@@280)) (forall (($generated@@281 T@U) ($generated@@282 T@U) ) (! (=> (and (and ($generated@@34 $generated@@281) ($generated@@44 $generated@@42 $generated@@282 $generated@@279)) ($generated@@39 $generated@@279 $generated@@280 $generated@@281 $generated@@278 $generated@@282)) ($generated@@44 $generated@@42 ($generated@@195 $generated@@279 $generated@@280 $generated@@281 $generated@@278 $generated@@282) $generated@@280)) - :pattern ( ($generated@@195 $generated@@279 $generated@@280 $generated@@281 $generated@@278 $generated@@282)) +(assert (forall (($generated@@248 T@U) ($generated@@249 T@U) ($generated@@250 T@U) ) (! (= ($generated@@36 $generated@@47 $generated@@248 ($generated@@82 $generated@@249 $generated@@250)) (forall (($generated@@251 T@U) ($generated@@252 T@U) ) (! (=> (and (and ($generated@@34 $generated@@251) ($generated@@44 $generated@@252 $generated@@249)) ($generated@@39 $generated@@249 $generated@@250 $generated@@251 $generated@@248 $generated@@252)) ($generated@@44 ($generated@@172 $generated@@249 $generated@@250 $generated@@251 $generated@@248 $generated@@252) $generated@@250)) + :pattern ( ($generated@@172 $generated@@249 $generated@@250 $generated@@251 $generated@@248 $generated@@252)) ))) - :pattern ( ($generated@@36 $generated@@47 $generated@@278 ($generated@@117 $generated@@279 $generated@@280))) + :pattern ( ($generated@@36 $generated@@47 $generated@@248 ($generated@@82 $generated@@249 $generated@@250))) ))) -(assert (forall (($generated@@283 T@U) ($generated@@284 T@U) ($generated@@285 T@T) ) (! (= ($generated@@44 $generated@@42 ($generated@@173 $generated@@285 $generated@@283) $generated@@284) ($generated@@36 $generated@@285 $generated@@283 $generated@@284)) - :pattern ( ($generated@@44 $generated@@42 ($generated@@173 $generated@@285 $generated@@283) $generated@@284)) +(assert (forall (($generated@@253 T@U) ($generated@@254 T@U) ($generated@@255 T@U) ($generated@@256 T@U) ) (! (=> ($generated@@34 $generated@@256) (= ($generated@@38 $generated@@47 $generated@@253 ($generated@@82 $generated@@254 $generated@@255) $generated@@256) (forall (($generated@@257 T@U) ) (! (=> (and (and ($generated@@44 $generated@@257 $generated@@254) ($generated@@151 $generated@@257 $generated@@254 $generated@@256)) ($generated@@39 $generated@@254 $generated@@255 $generated@@256 $generated@@253 $generated@@257)) (forall (($generated@@258 T@U) ) (! (=> (and (or (not (= $generated@@258 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@254 $generated@@255 $generated@@256 $generated@@253 $generated@@257) ($generated@@132 $generated@@91 $generated@@258)))) ($generated@@19 ($generated@@94 $generated@@15 ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@256 $generated@@258) $generated@@1)))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@254 $generated@@255 $generated@@256 $generated@@253 $generated@@257) ($generated@@132 $generated@@91 $generated@@258))) ))) -(assert (forall (($generated@@286 T@U) ($generated@@287 T@U) ($generated@@288 T@U) ($generated@@289 T@U) ($generated@@290 T@U) ($generated@@291 T@U) ($generated@@292 T@U) ) (! (=> ($generated@@19 ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@15 $generated@@290 $generated@@288 $generated@@292)) ($generated@@39 $generated@@286 $generated@@287 $generated@@288 ($generated@@196 $generated@@289 $generated@@290 $generated@@291) $generated@@292)) - :pattern ( ($generated@@39 $generated@@286 $generated@@287 $generated@@288 ($generated@@196 $generated@@289 $generated@@290 $generated@@291) $generated@@292)) + :pattern ( ($generated@@172 $generated@@254 $generated@@255 $generated@@256 $generated@@253 $generated@@257)) + :pattern ( ($generated@@117 $generated@@254 $generated@@255 $generated@@256 $generated@@253 $generated@@257)) +)))) + :pattern ( ($generated@@38 $generated@@47 $generated@@253 ($generated@@82 $generated@@254 $generated@@255) $generated@@256)) ))) -(assert (forall (($generated@@294 T@U) ($generated@@295 T@U) ) (! (= ($generated@@293 ($generated@@117 $generated@@294 $generated@@295)) $generated@@294) - :pattern ( ($generated@@117 $generated@@294 $generated@@295)) +(assert (forall (($generated@@259 T@U) ($generated@@260 T@U) ($generated@@261 T@T) ) (! (= ($generated@@44 ($generated@@132 $generated@@261 $generated@@259) $generated@@260) ($generated@@36 $generated@@261 $generated@@259 $generated@@260)) + :pattern ( ($generated@@44 ($generated@@132 $generated@@261 $generated@@259) $generated@@260)) ))) -(assert (forall (($generated@@297 T@U) ($generated@@298 T@U) ) (! (= ($generated@@296 ($generated@@117 $generated@@297 $generated@@298)) $generated@@298) - :pattern ( ($generated@@117 $generated@@297 $generated@@298)) +(assert (forall (($generated@@262 T@U) ($generated@@263 T@U) ($generated@@264 T@U) ($generated@@265 T@U) ($generated@@266 T@U) ($generated@@267 T@U) ($generated@@268 T@U) ) (! (=> ($generated@@19 ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@15 $generated@@266 $generated@@264 $generated@@268)) ($generated@@39 $generated@@262 $generated@@263 $generated@@264 ($generated@@173 $generated@@265 $generated@@266 $generated@@267) $generated@@268)) + :pattern ( ($generated@@39 $generated@@262 $generated@@263 $generated@@264 ($generated@@173 $generated@@265 $generated@@266 $generated@@267) $generated@@268)) ))) -(assert (forall (($generated@@300 T@U) ($generated@@301 T@U) ) (! (= ($generated@@299 ($generated@@126 $generated@@300 $generated@@301)) $generated@@300) - :pattern ( ($generated@@126 $generated@@300 $generated@@301)) +(assert (forall (($generated@@270 T@U) ($generated@@271 T@U) ) (! (= ($generated@@269 ($generated@@82 $generated@@270 $generated@@271)) $generated@@270) + :pattern ( ($generated@@82 $generated@@270 $generated@@271)) ))) -(assert (forall (($generated@@303 T@U) ($generated@@304 T@U) ) (! (= ($generated@@302 ($generated@@126 $generated@@303 $generated@@304)) $generated@@304) - :pattern ( ($generated@@126 $generated@@303 $generated@@304)) +(assert (forall (($generated@@273 T@U) ($generated@@274 T@U) ) (! (= ($generated@@272 ($generated@@82 $generated@@273 $generated@@274)) $generated@@274) + :pattern ( ($generated@@82 $generated@@273 $generated@@274)) ))) -(assert (forall (($generated@@305 T@U) ($generated@@306 T@U) ) (! (= ($generated@@115 ($generated@@150 $generated@@305 $generated@@306)) $generated@@7) - :pattern ( ($generated@@150 $generated@@305 $generated@@306)) +(assert (forall (($generated@@276 T@U) ($generated@@277 T@U) ) (! (= ($generated@@275 ($generated@@98 $generated@@276 $generated@@277)) $generated@@276) + :pattern ( ($generated@@98 $generated@@276 $generated@@277)) ))) -(assert (forall (($generated@@308 T@U) ($generated@@309 T@U) ) (! (= ($generated@@307 ($generated@@37 $generated@@308 $generated@@309)) $generated@@308) - :pattern ( ($generated@@37 $generated@@308 $generated@@309)) +(assert (forall (($generated@@279 T@U) ($generated@@280 T@U) ) (! (= ($generated@@278 ($generated@@98 $generated@@279 $generated@@280)) $generated@@280) + :pattern ( ($generated@@98 $generated@@279 $generated@@280)) ))) -(assert (forall (($generated@@311 T@U) ($generated@@312 T@U) ) (! (= ($generated@@310 ($generated@@37 $generated@@311 $generated@@312)) $generated@@312) - :pattern ( ($generated@@37 $generated@@311 $generated@@312)) +(assert (forall (($generated@@281 T@U) ($generated@@282 T@U) ) (! (= ($generated@@80 ($generated@@126 $generated@@281 $generated@@282)) $generated@@7) + :pattern ( ($generated@@126 $generated@@281 $generated@@282)) ))) -(assert (forall (($generated@@313 T@U) ($generated@@314 T@U) ) (! (= ($generated@@43 ($generated@@150 $generated@@313 $generated@@314)) $generated@@313) - :pattern ( ($generated@@150 $generated@@313 $generated@@314)) +(assert (forall (($generated@@284 T@U) ($generated@@285 T@U) ) (! (= ($generated@@283 ($generated@@37 $generated@@284 $generated@@285)) $generated@@284) + :pattern ( ($generated@@37 $generated@@284 $generated@@285)) ))) -(assert (forall (($generated@@315 T@U) ($generated@@316 T@U) ) (! (= ($generated@@40 ($generated@@150 $generated@@315 $generated@@316)) $generated@@316) - :pattern ( ($generated@@150 $generated@@315 $generated@@316)) +(assert (forall (($generated@@287 T@U) ($generated@@288 T@U) ) (! (= ($generated@@286 ($generated@@37 $generated@@287 $generated@@288)) $generated@@288) + :pattern ( ($generated@@37 $generated@@287 $generated@@288)) ))) -(assert (forall (($generated@@317 T@U) ) (! ($generated@@36 $generated@@77 $generated@@317 $generated@@108) - :pattern ( ($generated@@36 $generated@@77 $generated@@317 $generated@@108)) +(assert (forall (($generated@@289 T@U) ($generated@@290 T@U) ) (! (= ($generated@@43 ($generated@@126 $generated@@289 $generated@@290)) $generated@@289) + :pattern ( ($generated@@126 $generated@@289 $generated@@290)) ))) -(assert (and (forall (($generated@@321 T@T) ($generated@@322 T@T) ($generated@@323 T@T) ($generated@@324 T@U) ($generated@@325 T@U) ($generated@@326 T@U) ($generated@@327 T@U) ) (! (= ($generated@@318 $generated@@321 $generated@@322 $generated@@323 ($generated@@320 $generated@@321 $generated@@322 $generated@@323 $generated@@325 $generated@@326 $generated@@327 $generated@@324) $generated@@326 $generated@@327) $generated@@324) - :weight 0 -)) (and (and (forall (($generated@@328 T@T) ($generated@@329 T@T) ($generated@@330 T@T) ($generated@@331 T@T) ($generated@@332 T@U) ($generated@@333 T@U) ($generated@@334 T@U) ($generated@@335 T@U) ($generated@@336 T@U) ($generated@@337 T@U) ) (! (or (= $generated@@330 $generated@@331) (= ($generated@@318 $generated@@331 $generated@@328 $generated@@329 ($generated@@320 $generated@@330 $generated@@328 $generated@@329 $generated@@333 $generated@@334 $generated@@335 $generated@@332) $generated@@336 $generated@@337) ($generated@@318 $generated@@331 $generated@@328 $generated@@329 $generated@@333 $generated@@336 $generated@@337))) - :weight 0 -)) (forall (($generated@@338 T@T) ($generated@@339 T@T) ($generated@@340 T@T) ($generated@@341 T@T) ($generated@@342 T@U) ($generated@@343 T@U) ($generated@@344 T@U) ($generated@@345 T@U) ($generated@@346 T@U) ($generated@@347 T@U) ) (! (or (= $generated@@344 $generated@@346) (= ($generated@@318 $generated@@341 $generated@@338 $generated@@339 ($generated@@320 $generated@@340 $generated@@338 $generated@@339 $generated@@343 $generated@@344 $generated@@345 $generated@@342) $generated@@346 $generated@@347) ($generated@@318 $generated@@341 $generated@@338 $generated@@339 $generated@@343 $generated@@346 $generated@@347))) - :weight 0 -))) (forall (($generated@@348 T@T) ($generated@@349 T@T) ($generated@@350 T@T) ($generated@@351 T@T) ($generated@@352 T@U) ($generated@@353 T@U) ($generated@@354 T@U) ($generated@@355 T@U) ($generated@@356 T@U) ($generated@@357 T@U) ) (! (or (= $generated@@355 $generated@@357) (= ($generated@@318 $generated@@351 $generated@@348 $generated@@349 ($generated@@320 $generated@@350 $generated@@348 $generated@@349 $generated@@353 $generated@@354 $generated@@355 $generated@@352) $generated@@356 $generated@@357) ($generated@@318 $generated@@351 $generated@@348 $generated@@349 $generated@@353 $generated@@356 $generated@@357))) - :weight 0 -))))) -(assert (forall (($generated@@358 T@U) ($generated@@359 T@U) ($generated@@360 T@U) ($generated@@361 Bool) ($generated@@362 T@U) ($generated@@363 T@U) ($generated@@364 T@T) ) (! (= ($generated@@19 ($generated@@318 $generated@@364 $generated@@77 $generated@@15 ($generated@@319 $generated@@358 $generated@@359 $generated@@360 $generated@@361) $generated@@362 $generated@@363)) (=> (and (or (not (= $generated@@362 $generated@@358)) (not true)) ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@359 $generated@@362) $generated@@360)))) $generated@@361)) - :pattern ( ($generated@@318 $generated@@364 $generated@@77 $generated@@15 ($generated@@319 $generated@@358 $generated@@359 $generated@@360 $generated@@361) $generated@@362 $generated@@363)) +(assert (forall (($generated@@291 T@U) ($generated@@292 T@U) ) (! (= ($generated@@40 ($generated@@126 $generated@@291 $generated@@292)) $generated@@292) + :pattern ( ($generated@@126 $generated@@291 $generated@@292)) +))) +(assert (forall (($generated@@293 T@U) ) (! ($generated@@36 $generated@@91 $generated@@293 $generated@@92) + :pattern ( ($generated@@36 $generated@@91 $generated@@293 $generated@@92)) ))) -(assert (forall (($generated@@366 T@U) ($generated@@367 T@U) ($generated@@368 T@U) ($generated@@369 Bool) ($generated@@370 T@U) ($generated@@371 T@U) ($generated@@372 T@T) ) (! (= ($generated@@19 ($generated@@318 $generated@@372 $generated@@77 $generated@@15 ($generated@@365 $generated@@366 $generated@@367 $generated@@368 $generated@@369) $generated@@370 $generated@@371)) (=> (and (or (not (= $generated@@370 $generated@@366)) (not true)) ($generated@@19 ($generated@@75 $generated@@15 ($generated@@76 $generated@@15 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@367 $generated@@370) $generated@@368)))) $generated@@369)) - :pattern ( ($generated@@318 $generated@@372 $generated@@77 $generated@@15 ($generated@@365 $generated@@366 $generated@@367 $generated@@368 $generated@@369) $generated@@370 $generated@@371)) +(assert (forall (($generated@@295 T@U) ) (! (= ($generated@@294 ($generated@@107 $generated@@295)) $generated@@295) + :pattern ( ($generated@@107 $generated@@295)) ))) -(assert (forall (($generated@@374 T@U) ) (! (= ($generated@@373 ($generated@@131 $generated@@374)) $generated@@374) - :pattern ( ($generated@@131 $generated@@374)) +(assert (forall (($generated@@297 T@U) ) (! (= ($generated@@296 ($generated@@107 $generated@@297)) $generated) + :pattern ( ($generated@@107 $generated@@297)) ))) -(assert (forall (($generated@@376 T@U) ) (! (= ($generated@@375 ($generated@@131 $generated@@376)) $generated) - :pattern ( ($generated@@131 $generated@@376)) +(assert (forall (($generated@@299 T@U) ) (! (= ($generated@@298 ($generated@@111 $generated@@299)) $generated@@299) + :pattern ( ($generated@@111 $generated@@299)) ))) -(assert (forall (($generated@@378 T@U) ) (! (= ($generated@@377 ($generated@@135 $generated@@378)) $generated@@378) - :pattern ( ($generated@@135 $generated@@378)) +(assert (forall (($generated@@300 T@U) ) (! (= ($generated@@296 ($generated@@111 $generated@@300)) $generated@@0) + :pattern ( ($generated@@111 $generated@@300)) ))) -(assert (forall (($generated@@379 T@U) ) (! (= ($generated@@375 ($generated@@135 $generated@@379)) $generated@@0) - :pattern ( ($generated@@135 $generated@@379)) +(assert (forall (($generated@@301 T@U) ($generated@@302 T@T) ) (! (= ($generated@@94 $generated@@302 ($generated@@132 $generated@@302 $generated@@301)) $generated@@301) + :pattern ( ($generated@@132 $generated@@302 $generated@@301)) ))) -(assert (forall (($generated@@380 T@U) ($generated@@381 T@T) ) (! (= ($generated@@75 $generated@@381 ($generated@@173 $generated@@381 $generated@@380)) $generated@@380) - :pattern ( ($generated@@173 $generated@@381 $generated@@380)) +(assert (forall (($generated@@304 T@U) ($generated@@305 T@U) ($generated@@306 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@304 ($generated@@132 $generated@@33 $generated@@306))) (< ($generated@@303 $generated@@306) ($generated@@303 ($generated@@126 $generated@@304 $generated@@305)))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@304 ($generated@@132 $generated@@33 $generated@@306)) ($generated@@126 $generated@@304 $generated@@305)) ))) -(assert (forall (($generated@@383 T@U) ($generated@@384 T@U) ($generated@@385 T@U) ) (! (=> ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@383 ($generated@@173 $generated@@33 $generated@@385))) (< ($generated@@382 $generated@@385) ($generated@@382 ($generated@@150 $generated@@383 $generated@@384)))) - :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@383 ($generated@@173 $generated@@33 $generated@@385)) ($generated@@150 $generated@@383 $generated@@384)) +(assert (forall (($generated@@307 T@U) ($generated@@308 T@U) ($generated@@309 T@U) ) (! (= ($generated@@36 $generated@@47 $generated@@309 ($generated@@98 $generated@@307 $generated@@308)) (and ($generated@@36 $generated@@47 $generated@@309 ($generated@@82 $generated@@307 $generated@@308)) (forall (($generated@@310 T@U) ) (=> ($generated@@44 $generated@@310 $generated@@307) ($generated@@119 ($generated@@117 $generated@@307 $generated@@308 $generated@@118 $generated@@309 $generated@@310) $generated@@120))))) + :pattern ( ($generated@@36 $generated@@47 $generated@@309 ($generated@@98 $generated@@307 $generated@@308))) ))) -(assert (forall (($generated@@386 T@U) ($generated@@387 T@U) ($generated@@388 T@U) ($generated@@389 T@U) ($generated@@390 T@U) ($generated@@391 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@388 $generated@@389) (and ($generated@@34 $generated@@388) ($generated@@34 $generated@@389))) (and ($generated@@44 $generated@@42 $generated@@391 $generated@@386) ($generated@@36 $generated@@47 $generated@@390 ($generated@@117 $generated@@386 $generated@@387)))) (forall (($generated@@392 T@U) ($generated@@393 T@U) ($generated@@394 T@T) ) (=> (and (or (not (= $generated@@392 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@386 $generated@@387 $generated@@388 $generated@@390 $generated@@391) ($generated@@173 $generated@@77 $generated@@392)))) (= ($generated@@75 $generated@@394 ($generated@@76 $generated@@394 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@388 $generated@@392) $generated@@393)) ($generated@@75 $generated@@394 ($generated@@76 $generated@@394 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@389 $generated@@392) $generated@@393)))))) (= ($generated@@39 $generated@@386 $generated@@387 $generated@@388 $generated@@390 $generated@@391) ($generated@@39 $generated@@386 $generated@@387 $generated@@389 $generated@@390 $generated@@391))) - :pattern ( ($generated@@74 $generated@@388 $generated@@389) ($generated@@39 $generated@@386 $generated@@387 $generated@@389 $generated@@390 $generated@@391)) +(assert (forall (($generated@@312 T@U) ($generated@@313 T@U) ($generated@@314 T@T) ) (! (= ($generated@@141 $generated@@314 $generated@@312 ($generated@@311 $generated@@313)) ($generated@@141 $generated@@314 $generated@@312 $generated@@313)) + :pattern ( ($generated@@141 $generated@@314 $generated@@312 ($generated@@311 $generated@@313))) ))) -(assert (forall (($generated@@395 T@U) ($generated@@396 T@U) ($generated@@397 T@U) ($generated@@398 T@U) ($generated@@399 T@U) ($generated@@400 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@397 $generated@@398) (and ($generated@@34 $generated@@397) ($generated@@34 $generated@@398))) (and ($generated@@44 $generated@@42 $generated@@400 $generated@@395) ($generated@@36 $generated@@47 $generated@@399 ($generated@@117 $generated@@395 $generated@@396)))) (forall (($generated@@401 T@U) ($generated@@402 T@U) ($generated@@403 T@T) ) (=> (and (or (not (= $generated@@401 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@395 $generated@@396 $generated@@398 $generated@@399 $generated@@400) ($generated@@173 $generated@@77 $generated@@401)))) (= ($generated@@75 $generated@@403 ($generated@@76 $generated@@403 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@397 $generated@@401) $generated@@402)) ($generated@@75 $generated@@403 ($generated@@76 $generated@@403 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@398 $generated@@401) $generated@@402)))))) (= ($generated@@39 $generated@@395 $generated@@396 $generated@@397 $generated@@399 $generated@@400) ($generated@@39 $generated@@395 $generated@@396 $generated@@398 $generated@@399 $generated@@400))) - :pattern ( ($generated@@74 $generated@@397 $generated@@398) ($generated@@39 $generated@@395 $generated@@396 $generated@@398 $generated@@399 $generated@@400)) +(assert (forall (($generated@@315 T@U) ($generated@@316 T@U) ($generated@@317 T@U) ) (! (=> ($generated@@44 $generated@@317 ($generated@@82 $generated@@315 $generated@@316)) (and (= ($generated@@132 $generated@@47 ($generated@@94 $generated@@47 $generated@@317)) $generated@@317) ($generated@@36 $generated@@47 ($generated@@94 $generated@@47 $generated@@317) ($generated@@82 $generated@@315 $generated@@316)))) + :pattern ( ($generated@@44 $generated@@317 ($generated@@82 $generated@@315 $generated@@316))) ))) -(assert (forall (($generated@@404 T@U) ($generated@@405 T@U) ($generated@@406 T@U) ) (! (= ($generated@@36 $generated@@47 $generated@@406 ($generated@@126 $generated@@404 $generated@@405)) (and ($generated@@36 $generated@@47 $generated@@406 ($generated@@117 $generated@@404 $generated@@405)) (forall (($generated@@407 T@U) ) (=> ($generated@@44 $generated@@42 $generated@@407 $generated@@404) ($generated@@143 $generated@@42 ($generated@@141 $generated@@404 $generated@@405 $generated@@142 $generated@@406 $generated@@407) ($generated@@144 $generated@@42)))))) - :pattern ( ($generated@@36 $generated@@47 $generated@@406 ($generated@@126 $generated@@404 $generated@@405))) +(assert (forall (($generated@@318 T@U) ($generated@@319 T@U) ($generated@@320 T@U) ) (! (=> ($generated@@44 $generated@@320 ($generated@@98 $generated@@318 $generated@@319)) (and (= ($generated@@132 $generated@@47 ($generated@@94 $generated@@47 $generated@@320)) $generated@@320) ($generated@@36 $generated@@47 ($generated@@94 $generated@@47 $generated@@320) ($generated@@98 $generated@@318 $generated@@319)))) + :pattern ( ($generated@@44 $generated@@320 ($generated@@98 $generated@@318 $generated@@319))) ))) -(assert (forall (($generated@@409 T@U) ($generated@@410 T@U) ($generated@@411 T@T) ) (! (= ($generated@@162 $generated@@411 $generated@@409 ($generated@@408 $generated@@410)) ($generated@@162 $generated@@411 $generated@@409 $generated@@410)) - :pattern ( ($generated@@162 $generated@@411 $generated@@409 ($generated@@408 $generated@@410))) +(assert (forall (($generated@@321 T@U) ($generated@@322 T@U) ($generated@@323 T@U) ) (! (=> ($generated@@44 $generated@@323 ($generated@@37 $generated@@321 $generated@@322)) (and (= ($generated@@132 $generated@@33 ($generated@@94 $generated@@33 $generated@@323)) $generated@@323) ($generated@@36 $generated@@33 ($generated@@94 $generated@@33 $generated@@323) ($generated@@37 $generated@@321 $generated@@322)))) + :pattern ( ($generated@@44 $generated@@323 ($generated@@37 $generated@@321 $generated@@322))) ))) -(assert (forall (($generated@@412 T@U) ($generated@@413 T@U) ($generated@@414 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@414 ($generated@@117 $generated@@412 $generated@@413)) (and (= ($generated@@173 $generated@@47 ($generated@@75 $generated@@47 $generated@@414)) $generated@@414) ($generated@@36 $generated@@47 ($generated@@75 $generated@@47 $generated@@414) ($generated@@117 $generated@@412 $generated@@413)))) - :pattern ( ($generated@@44 $generated@@42 $generated@@414 ($generated@@117 $generated@@412 $generated@@413))) +(assert (forall (($generated@@324 T@U) ) (! (not ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@120 $generated@@324))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@120 $generated@@324)) ))) -(assert (forall (($generated@@415 T@U) ($generated@@416 T@U) ($generated@@417 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@417 ($generated@@126 $generated@@415 $generated@@416)) (and (= ($generated@@173 $generated@@47 ($generated@@75 $generated@@47 $generated@@417)) $generated@@417) ($generated@@36 $generated@@47 ($generated@@75 $generated@@47 $generated@@417) ($generated@@126 $generated@@415 $generated@@416)))) - :pattern ( ($generated@@44 $generated@@42 $generated@@417 ($generated@@126 $generated@@415 $generated@@416))) +(assert (forall (($generated@@326 T@U) ) (! (not ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 $generated@@325 $generated@@326))) + :pattern ( ($generated@@41 $generated@@42 $generated@@15 $generated@@325 $generated@@326)) ))) -(assert (forall (($generated@@418 T@U) ($generated@@419 T@U) ($generated@@420 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@420 ($generated@@37 $generated@@418 $generated@@419)) (and (= ($generated@@173 $generated@@33 ($generated@@75 $generated@@33 $generated@@420)) $generated@@420) ($generated@@36 $generated@@33 ($generated@@75 $generated@@33 $generated@@420) ($generated@@37 $generated@@418 $generated@@419)))) - :pattern ( ($generated@@44 $generated@@42 $generated@@420 ($generated@@37 $generated@@418 $generated@@419))) +(assert (forall (($generated@@328 T@U) ($generated@@329 T@U) ($generated@@330 T@U) ($generated@@331 Bool) ($generated@@332 T@U) ($generated@@333 T@U) ) (! (= ($generated@@19 ($generated@@174 $generated@@91 $generated@@95 $generated@@15 ($generated@@327 $generated@@328 $generated@@329 $generated@@330 $generated@@331) $generated@@332 $generated@@333)) (=> (and (or (not (= $generated@@332 $generated@@328)) (not true)) ($generated@@19 ($generated@@94 $generated@@15 ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@329 $generated@@332) $generated@@330)))) $generated@@331)) + :pattern ( ($generated@@174 $generated@@91 $generated@@95 $generated@@15 ($generated@@327 $generated@@328 $generated@@329 $generated@@330 $generated@@331) $generated@@332 $generated@@333)) ))) -(assert (forall (($generated@@421 T@U) ($generated@@422 T@T) ) (! (not ($generated@@19 ($generated@@41 $generated@@422 $generated@@15 ($generated@@144 $generated@@422) $generated@@421))) - :pattern ( ($generated@@41 $generated@@422 $generated@@15 ($generated@@144 $generated@@422) $generated@@421)) +(assert (forall (($generated@@335 T@U) ($generated@@336 T@U) ) (! (and (= ($generated@@296 ($generated@@82 $generated@@335 $generated@@336)) $generated@@3) (= ($generated@@334 ($generated@@82 $generated@@335 $generated@@336)) $generated@@10)) + :pattern ( ($generated@@82 $generated@@335 $generated@@336)) ))) -(assert (forall (($generated@@424 T@U) ($generated@@425 T@T) ) (! (not ($generated@@19 ($generated@@41 $generated@@425 $generated@@15 ($generated@@423 $generated@@425) $generated@@424))) - :pattern ( ($generated@@41 $generated@@425 $generated@@15 ($generated@@423 $generated@@425) $generated@@424)) +(assert (forall (($generated@@337 T@U) ($generated@@338 T@U) ) (! (and (= ($generated@@296 ($generated@@98 $generated@@337 $generated@@338)) $generated@@4) (= ($generated@@334 ($generated@@98 $generated@@337 $generated@@338)) $generated@@11)) + :pattern ( ($generated@@98 $generated@@337 $generated@@338)) ))) -(assert (forall (($generated@@427 T@U) ($generated@@428 T@U) ) (! (and (= ($generated@@375 ($generated@@117 $generated@@427 $generated@@428)) $generated@@3) (= ($generated@@426 ($generated@@117 $generated@@427 $generated@@428)) $generated@@10)) - :pattern ( ($generated@@117 $generated@@427 $generated@@428)) +(assert (forall (($generated@@339 T@U) ($generated@@340 T@U) ) (! (and (= ($generated@@296 ($generated@@37 $generated@@339 $generated@@340)) $generated@@8) (= ($generated@@334 ($generated@@37 $generated@@339 $generated@@340)) $generated@@13)) + :pattern ( ($generated@@37 $generated@@339 $generated@@340)) ))) -(assert (forall (($generated@@429 T@U) ($generated@@430 T@U) ) (! (and (= ($generated@@375 ($generated@@126 $generated@@429 $generated@@430)) $generated@@4) (= ($generated@@426 ($generated@@126 $generated@@429 $generated@@430)) $generated@@11)) - :pattern ( ($generated@@126 $generated@@429 $generated@@430)) +(assert (forall (($generated@@341 T@U) ($generated@@342 T@U) ($generated@@343 T@U) ($generated@@344 T@U) ($generated@@345 T@U) ) (! (=> (and (and ($generated@@34 $generated@@343) (and ($generated@@44 $generated@@345 $generated@@341) ($generated@@36 $generated@@47 $generated@@344 ($generated@@82 $generated@@341 $generated@@342)))) ($generated@@119 ($generated@@117 $generated@@341 $generated@@342 $generated@@118 $generated@@344 $generated@@345) $generated@@120)) (= ($generated@@39 $generated@@341 $generated@@342 $generated@@118 $generated@@344 $generated@@345) ($generated@@39 $generated@@341 $generated@@342 $generated@@343 $generated@@344 $generated@@345))) + :pattern ( ($generated@@39 $generated@@341 $generated@@342 $generated@@118 $generated@@344 $generated@@345) ($generated@@34 $generated@@343)) + :pattern ( ($generated@@39 $generated@@341 $generated@@342 $generated@@343 $generated@@344 $generated@@345)) ))) -(assert (forall (($generated@@431 T@U) ($generated@@432 T@U) ) (! (and (= ($generated@@375 ($generated@@37 $generated@@431 $generated@@432)) $generated@@8) (= ($generated@@426 ($generated@@37 $generated@@431 $generated@@432)) $generated@@13)) - :pattern ( ($generated@@37 $generated@@431 $generated@@432)) +(assert (forall (($generated@@346 T@U) ($generated@@347 T@U) ) (! (=> ($generated@@44 $generated@@346 ($generated@@107 $generated@@347)) (and (= ($generated@@132 ($generated@@46 $generated@@42 $generated@@15) ($generated@@94 ($generated@@46 $generated@@42 $generated@@15) $generated@@346)) $generated@@346) ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@94 ($generated@@46 $generated@@42 $generated@@15) $generated@@346) ($generated@@107 $generated@@347)))) + :pattern ( ($generated@@44 $generated@@346 ($generated@@107 $generated@@347))) ))) -(assert (forall (($generated@@433 T@U) ($generated@@434 T@U) ($generated@@435 T@U) ($generated@@436 T@U) ($generated@@437 T@U) ) (! (=> (and (and ($generated@@34 $generated@@435) (and ($generated@@44 $generated@@42 $generated@@437 $generated@@433) ($generated@@36 $generated@@47 $generated@@436 ($generated@@117 $generated@@433 $generated@@434)))) ($generated@@143 $generated@@42 ($generated@@141 $generated@@433 $generated@@434 $generated@@142 $generated@@436 $generated@@437) ($generated@@144 $generated@@42))) (= ($generated@@39 $generated@@433 $generated@@434 $generated@@142 $generated@@436 $generated@@437) ($generated@@39 $generated@@433 $generated@@434 $generated@@435 $generated@@436 $generated@@437))) - :pattern ( ($generated@@39 $generated@@433 $generated@@434 $generated@@142 $generated@@436 $generated@@437) ($generated@@34 $generated@@435)) - :pattern ( ($generated@@39 $generated@@433 $generated@@434 $generated@@435 $generated@@436 $generated@@437)) +(assert (forall (($generated@@348 T@U) ($generated@@349 T@U) ) (! (=> ($generated@@44 $generated@@348 ($generated@@111 $generated@@349)) (and (= ($generated@@132 ($generated@@46 $generated@@42 $generated@@15) ($generated@@94 ($generated@@46 $generated@@42 $generated@@15) $generated@@348)) $generated@@348) ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@94 ($generated@@46 $generated@@42 $generated@@15) $generated@@348) ($generated@@111 $generated@@349)))) + :pattern ( ($generated@@44 $generated@@348 ($generated@@111 $generated@@349))) ))) -(assert (forall (($generated@@438 T@U) ($generated@@439 T@U) ($generated@@440 T@U) ($generated@@441 T@U) ($generated@@442 T@U) ($generated@@443 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@440 $generated@@441) (and ($generated@@34 $generated@@440) ($generated@@34 $generated@@441))) (and ($generated@@44 $generated@@42 $generated@@443 $generated@@438) ($generated@@36 $generated@@47 $generated@@442 ($generated@@117 $generated@@438 $generated@@439)))) (forall (($generated@@444 T@U) ($generated@@445 T@U) ($generated@@446 T@T) ) (=> (and (or (not (= $generated@@444 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@438 $generated@@439 $generated@@440 $generated@@442 $generated@@443) ($generated@@173 $generated@@77 $generated@@444)))) (= ($generated@@75 $generated@@446 ($generated@@76 $generated@@446 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@440 $generated@@444) $generated@@445)) ($generated@@75 $generated@@446 ($generated@@76 $generated@@446 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@441 $generated@@444) $generated@@445)))))) (= ($generated@@141 $generated@@438 $generated@@439 $generated@@440 $generated@@442 $generated@@443) ($generated@@141 $generated@@438 $generated@@439 $generated@@441 $generated@@442 $generated@@443))) - :pattern ( ($generated@@74 $generated@@440 $generated@@441) ($generated@@141 $generated@@438 $generated@@439 $generated@@441 $generated@@442 $generated@@443)) +(assert (forall (($generated@@350 T@U) ($generated@@351 T@U) ) (! (=> (and ($generated@@34 $generated@@351) ($generated@@36 $generated@@33 $generated@@350 $generated@@90)) ($generated@@38 $generated@@33 $generated@@350 $generated@@90 $generated@@351)) + :pattern ( ($generated@@38 $generated@@33 $generated@@350 $generated@@90 $generated@@351)) ))) -(assert (forall (($generated@@447 T@U) ($generated@@448 T@U) ($generated@@449 T@U) ($generated@@450 T@U) ($generated@@451 T@U) ($generated@@452 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@449 $generated@@450) (and ($generated@@34 $generated@@449) ($generated@@34 $generated@@450))) (and ($generated@@44 $generated@@42 $generated@@452 $generated@@447) ($generated@@36 $generated@@47 $generated@@451 ($generated@@117 $generated@@447 $generated@@448)))) (forall (($generated@@453 T@U) ($generated@@454 T@U) ($generated@@455 T@T) ) (=> (and (or (not (= $generated@@453 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@447 $generated@@448 $generated@@450 $generated@@451 $generated@@452) ($generated@@173 $generated@@77 $generated@@453)))) (= ($generated@@75 $generated@@455 ($generated@@76 $generated@@455 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@449 $generated@@453) $generated@@454)) ($generated@@75 $generated@@455 ($generated@@76 $generated@@455 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@450 $generated@@453) $generated@@454)))))) (= ($generated@@141 $generated@@447 $generated@@448 $generated@@449 $generated@@451 $generated@@452) ($generated@@141 $generated@@447 $generated@@448 $generated@@450 $generated@@451 $generated@@452))) - :pattern ( ($generated@@74 $generated@@449 $generated@@450) ($generated@@141 $generated@@447 $generated@@448 $generated@@450 $generated@@451 $generated@@452)) +(assert (= ($generated@@296 $generated@@92) $generated@@2)) +(assert (= ($generated@@334 $generated@@92) $generated@@9)) +(assert (= ($generated@@296 $generated@@90) $generated@@6)) +(assert (= ($generated@@334 $generated@@90) $generated@@12)) +(assert (= $generated@@81 ($generated@@32 $generated@@33 $generated@@81))) +(assert (forall (($generated@@352 T@U) ) (! ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@138 $generated@@352) ($generated@@107 $generated@@92)) + :pattern ( ($generated@@138 $generated@@352)) ))) -(assert (forall (($generated@@456 T@U) ($generated@@457 T@U) ($generated@@458 T@U) ($generated@@459 T@U) ($generated@@460 T@U) ($generated@@461 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@458 $generated@@459) (and ($generated@@34 $generated@@458) ($generated@@34 $generated@@459))) (and ($generated@@44 $generated@@42 $generated@@461 $generated@@456) ($generated@@36 $generated@@47 $generated@@460 ($generated@@117 $generated@@456 $generated@@457)))) (forall (($generated@@462 T@U) ($generated@@463 T@U) ($generated@@464 T@T) ) (=> (and (or (not (= $generated@@462 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@456 $generated@@457 $generated@@458 $generated@@460 $generated@@461) ($generated@@173 $generated@@77 $generated@@462)))) (= ($generated@@75 $generated@@464 ($generated@@76 $generated@@464 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@458 $generated@@462) $generated@@463)) ($generated@@75 $generated@@464 ($generated@@76 $generated@@464 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@459 $generated@@462) $generated@@463)))))) (= ($generated@@195 $generated@@456 $generated@@457 $generated@@458 $generated@@460 $generated@@461) ($generated@@195 $generated@@456 $generated@@457 $generated@@459 $generated@@460 $generated@@461))) - :pattern ( ($generated@@74 $generated@@458 $generated@@459) ($generated@@195 $generated@@456 $generated@@457 $generated@@459 $generated@@460 $generated@@461)) +(assert (forall (($generated@@353 T@U) ($generated@@354 T@U) ($generated@@355 T@U) ($generated@@356 T@U) ($generated@@357 T@U) ($generated@@358 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@355 $generated@@356) (and ($generated@@34 $generated@@355) ($generated@@34 $generated@@356))) (and ($generated@@44 $generated@@358 $generated@@353) ($generated@@36 $generated@@47 $generated@@357 ($generated@@82 $generated@@353 $generated@@354)))) (forall (($generated@@359 T@U) ($generated@@360 T@U) ) (=> (and (or (not (= $generated@@359 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@353 $generated@@354 $generated@@355 $generated@@357 $generated@@358) ($generated@@132 $generated@@91 $generated@@359)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@355 $generated@@359) $generated@@360) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@356 $generated@@359) $generated@@360))))) (= ($generated@@39 $generated@@353 $generated@@354 $generated@@355 $generated@@357 $generated@@358) ($generated@@39 $generated@@353 $generated@@354 $generated@@356 $generated@@357 $generated@@358))) + :pattern ( ($generated@@103 $generated@@355 $generated@@356) ($generated@@39 $generated@@353 $generated@@354 $generated@@356 $generated@@357 $generated@@358)) ))) -(assert (forall (($generated@@465 T@U) ($generated@@466 T@U) ($generated@@467 T@U) ($generated@@468 T@U) ($generated@@469 T@U) ($generated@@470 T@U) ) (! (=> (and (and (and ($generated@@74 $generated@@467 $generated@@468) (and ($generated@@34 $generated@@467) ($generated@@34 $generated@@468))) (and ($generated@@44 $generated@@42 $generated@@470 $generated@@465) ($generated@@36 $generated@@47 $generated@@469 ($generated@@117 $generated@@465 $generated@@466)))) (forall (($generated@@471 T@U) ($generated@@472 T@U) ($generated@@473 T@T) ) (=> (and (or (not (= $generated@@471 $generated@@109)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@141 $generated@@465 $generated@@466 $generated@@468 $generated@@469 $generated@@470) ($generated@@173 $generated@@77 $generated@@471)))) (= ($generated@@75 $generated@@473 ($generated@@76 $generated@@473 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@467 $generated@@471) $generated@@472)) ($generated@@75 $generated@@473 ($generated@@76 $generated@@473 $generated@@42 ($generated@@41 $generated@@77 ($generated@@78 $generated@@42) $generated@@468 $generated@@471) $generated@@472)))))) (= ($generated@@195 $generated@@465 $generated@@466 $generated@@467 $generated@@469 $generated@@470) ($generated@@195 $generated@@465 $generated@@466 $generated@@468 $generated@@469 $generated@@470))) - :pattern ( ($generated@@74 $generated@@467 $generated@@468) ($generated@@195 $generated@@465 $generated@@466 $generated@@468 $generated@@469 $generated@@470)) +(assert (forall (($generated@@361 T@U) ($generated@@362 T@U) ($generated@@363 T@U) ($generated@@364 T@U) ($generated@@365 T@U) ($generated@@366 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@363 $generated@@364) (and ($generated@@34 $generated@@363) ($generated@@34 $generated@@364))) (and ($generated@@44 $generated@@366 $generated@@361) ($generated@@36 $generated@@47 $generated@@365 ($generated@@82 $generated@@361 $generated@@362)))) (forall (($generated@@367 T@U) ($generated@@368 T@U) ) (=> (and (or (not (= $generated@@367 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@361 $generated@@362 $generated@@364 $generated@@365 $generated@@366) ($generated@@132 $generated@@91 $generated@@367)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@363 $generated@@367) $generated@@368) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@364 $generated@@367) $generated@@368))))) (= ($generated@@39 $generated@@361 $generated@@362 $generated@@363 $generated@@365 $generated@@366) ($generated@@39 $generated@@361 $generated@@362 $generated@@364 $generated@@365 $generated@@366))) + :pattern ( ($generated@@103 $generated@@363 $generated@@364) ($generated@@39 $generated@@361 $generated@@362 $generated@@364 $generated@@365 $generated@@366)) ))) -(assert (forall (($generated@@474 T@U) ($generated@@475 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@474 ($generated@@131 $generated@@475)) (and (= ($generated@@173 ($generated@@46 $generated@@42 $generated@@15) ($generated@@75 ($generated@@46 $generated@@42 $generated@@15) $generated@@474)) $generated@@474) ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@75 ($generated@@46 $generated@@42 $generated@@15) $generated@@474) ($generated@@131 $generated@@475)))) - :pattern ( ($generated@@44 $generated@@42 $generated@@474 ($generated@@131 $generated@@475))) +(assert (forall (($generated@@369 T@U) ($generated@@370 T@U) ) (! (= ($generated@@126 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@369) ($generated@@32 $generated@@47 $generated@@370)) ($generated@@32 $generated@@33 ($generated@@126 $generated@@369 $generated@@370))) + :pattern ( ($generated@@126 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@369) ($generated@@32 $generated@@47 $generated@@370))) ))) -(assert (forall (($generated@@476 T@U) ($generated@@477 T@U) ) (! (=> ($generated@@44 $generated@@42 $generated@@476 ($generated@@135 $generated@@477)) (and (= ($generated@@173 ($generated@@46 $generated@@42 $generated@@15) ($generated@@75 ($generated@@46 $generated@@42 $generated@@15) $generated@@476)) $generated@@476) ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@75 ($generated@@46 $generated@@42 $generated@@15) $generated@@476) ($generated@@135 $generated@@477)))) - :pattern ( ($generated@@44 $generated@@42 $generated@@476 ($generated@@135 $generated@@477))) +(assert (forall (($generated@@371 T@U) ($generated@@372 T@T) ) (! (= ($generated@@132 $generated@@372 ($generated@@32 $generated@@372 $generated@@371)) ($generated@@32 $generated@@42 ($generated@@132 $generated@@372 $generated@@371))) + :pattern ( ($generated@@132 $generated@@372 ($generated@@32 $generated@@372 $generated@@371))) ))) -(assert (forall (($generated@@478 T@U) ($generated@@479 T@U) ) (! (=> (and ($generated@@34 $generated@@479) ($generated@@36 $generated@@33 $generated@@478 $generated@@125)) ($generated@@38 $generated@@33 $generated@@478 $generated@@125 $generated@@479)) - :pattern ( ($generated@@38 $generated@@33 $generated@@478 $generated@@125 $generated@@479)) +(assert (forall (($generated@@373 T@U) ($generated@@374 T@U) ($generated@@375 T@U) ($generated@@376 T@U) ($generated@@377 T@U) ($generated@@378 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@375 $generated@@376) (and ($generated@@34 $generated@@375) ($generated@@34 $generated@@376))) (and ($generated@@44 $generated@@378 $generated@@373) ($generated@@36 $generated@@47 $generated@@377 ($generated@@82 $generated@@373 $generated@@374)))) (forall (($generated@@379 T@U) ($generated@@380 T@U) ) (=> (and (or (not (= $generated@@379 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@373 $generated@@374 $generated@@375 $generated@@377 $generated@@378) ($generated@@132 $generated@@91 $generated@@379)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@375 $generated@@379) $generated@@380) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@376 $generated@@379) $generated@@380))))) (= ($generated@@117 $generated@@373 $generated@@374 $generated@@375 $generated@@377 $generated@@378) ($generated@@117 $generated@@373 $generated@@374 $generated@@376 $generated@@377 $generated@@378))) + :pattern ( ($generated@@103 $generated@@375 $generated@@376) ($generated@@117 $generated@@373 $generated@@374 $generated@@376 $generated@@377 $generated@@378)) ))) -(assert (= ($generated@@375 $generated@@108) $generated@@2)) -(assert (= ($generated@@426 $generated@@108) $generated@@9)) -(assert (= ($generated@@375 $generated@@125) $generated@@6)) -(assert (= ($generated@@426 $generated@@125) $generated@@12)) -(assert (= $generated@@116 ($generated@@32 $generated@@33 $generated@@116))) -(assert (forall (($generated@@480 T@U) ) (! ($generated@@36 ($generated@@46 $generated@@42 $generated@@15) ($generated@@159 $generated@@480) ($generated@@131 $generated@@108)) - :pattern ( ($generated@@159 $generated@@480)) +(assert (forall (($generated@@381 T@U) ($generated@@382 T@U) ($generated@@383 T@U) ($generated@@384 T@U) ($generated@@385 T@U) ($generated@@386 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@383 $generated@@384) (and ($generated@@34 $generated@@383) ($generated@@34 $generated@@384))) (and ($generated@@44 $generated@@386 $generated@@381) ($generated@@36 $generated@@47 $generated@@385 ($generated@@82 $generated@@381 $generated@@382)))) (forall (($generated@@387 T@U) ($generated@@388 T@U) ) (=> (and (or (not (= $generated@@387 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@381 $generated@@382 $generated@@384 $generated@@385 $generated@@386) ($generated@@132 $generated@@91 $generated@@387)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@383 $generated@@387) $generated@@388) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@384 $generated@@387) $generated@@388))))) (= ($generated@@117 $generated@@381 $generated@@382 $generated@@383 $generated@@385 $generated@@386) ($generated@@117 $generated@@381 $generated@@382 $generated@@384 $generated@@385 $generated@@386))) + :pattern ( ($generated@@103 $generated@@383 $generated@@384) ($generated@@117 $generated@@381 $generated@@382 $generated@@384 $generated@@385 $generated@@386)) ))) -(assert (forall (($generated@@481 T@U) ($generated@@482 T@U) ) (! (= ($generated@@150 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@481) ($generated@@32 $generated@@47 $generated@@482)) ($generated@@32 $generated@@33 ($generated@@150 $generated@@481 $generated@@482))) - :pattern ( ($generated@@150 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@481) ($generated@@32 $generated@@47 $generated@@482))) +(assert (forall (($generated@@389 T@U) ($generated@@390 T@U) ($generated@@391 T@U) ($generated@@392 T@U) ($generated@@393 T@U) ($generated@@394 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@391 $generated@@392) (and ($generated@@34 $generated@@391) ($generated@@34 $generated@@392))) (and ($generated@@44 $generated@@394 $generated@@389) ($generated@@36 $generated@@47 $generated@@393 ($generated@@82 $generated@@389 $generated@@390)))) (forall (($generated@@395 T@U) ($generated@@396 T@U) ) (=> (and (or (not (= $generated@@395 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@389 $generated@@390 $generated@@391 $generated@@393 $generated@@394) ($generated@@132 $generated@@91 $generated@@395)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@391 $generated@@395) $generated@@396) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@392 $generated@@395) $generated@@396))))) (= ($generated@@172 $generated@@389 $generated@@390 $generated@@391 $generated@@393 $generated@@394) ($generated@@172 $generated@@389 $generated@@390 $generated@@392 $generated@@393 $generated@@394))) + :pattern ( ($generated@@103 $generated@@391 $generated@@392) ($generated@@172 $generated@@389 $generated@@390 $generated@@392 $generated@@393 $generated@@394)) ))) -(assert (forall (($generated@@483 T@U) ($generated@@484 T@T) ) (! (= ($generated@@173 $generated@@484 ($generated@@32 $generated@@484 $generated@@483)) ($generated@@32 $generated@@42 ($generated@@173 $generated@@484 $generated@@483))) - :pattern ( ($generated@@173 $generated@@484 ($generated@@32 $generated@@484 $generated@@483))) +(assert (forall (($generated@@397 T@U) ($generated@@398 T@U) ($generated@@399 T@U) ($generated@@400 T@U) ($generated@@401 T@U) ($generated@@402 T@U) ) (! (=> (and (and (and ($generated@@103 $generated@@399 $generated@@400) (and ($generated@@34 $generated@@399) ($generated@@34 $generated@@400))) (and ($generated@@44 $generated@@402 $generated@@397) ($generated@@36 $generated@@47 $generated@@401 ($generated@@82 $generated@@397 $generated@@398)))) (forall (($generated@@403 T@U) ($generated@@404 T@U) ) (=> (and (or (not (= $generated@@403 $generated@@93)) (not true)) ($generated@@19 ($generated@@41 $generated@@42 $generated@@15 ($generated@@117 $generated@@397 $generated@@398 $generated@@400 $generated@@401 $generated@@402) ($generated@@132 $generated@@91 $generated@@403)))) (= ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@399 $generated@@403) $generated@@404) ($generated@@41 $generated@@95 $generated@@42 ($generated@@41 $generated@@91 ($generated@@46 $generated@@95 $generated@@42) $generated@@400 $generated@@403) $generated@@404))))) (= ($generated@@172 $generated@@397 $generated@@398 $generated@@399 $generated@@401 $generated@@402) ($generated@@172 $generated@@397 $generated@@398 $generated@@400 $generated@@401 $generated@@402))) + :pattern ( ($generated@@103 $generated@@399 $generated@@400) ($generated@@172 $generated@@397 $generated@@398 $generated@@400 $generated@@401 $generated@@402)) ))) -(assert (forall (($generated@@485 T@U) ($generated@@486 T@U) ($generated@@487 T@U) ) (! (=> (and ($generated@@34 $generated@@487) (and ($generated@@45 $generated@@485) (exists (($generated@@488 T@U) ) (! ($generated@@38 $generated@@33 $generated@@485 ($generated@@37 $generated@@486 $generated@@488) $generated@@487) - :pattern ( ($generated@@38 $generated@@33 $generated@@485 ($generated@@37 $generated@@486 $generated@@488) $generated@@487)) -)))) ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 $generated@@485) ($generated@@135 $generated@@486) $generated@@487)) - :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 $generated@@485) ($generated@@135 $generated@@486) $generated@@487)) +(assert (forall (($generated@@405 T@U) ($generated@@406 T@U) ($generated@@407 T@U) ) (! (=> (and ($generated@@34 $generated@@407) (and ($generated@@45 $generated@@405) (exists (($generated@@408 T@U) ) (! ($generated@@38 $generated@@33 $generated@@405 ($generated@@37 $generated@@406 $generated@@408) $generated@@407) + :pattern ( ($generated@@38 $generated@@33 $generated@@405 ($generated@@37 $generated@@406 $generated@@408) $generated@@407)) +)))) ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 $generated@@405) ($generated@@111 $generated@@406) $generated@@407)) + :pattern ( ($generated@@38 ($generated@@46 $generated@@42 $generated@@15) ($generated@@43 $generated@@405) ($generated@@111 $generated@@406) $generated@@407)) ))) -(assert (forall (($generated@@490 T@U) ($generated@@491 T@U) ($generated@@492 T@U) ) (! (= ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) ($generated@@489 $generated@@490) $generated@@491 $generated@@492) $generated@@490) - :pattern ( ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) ($generated@@489 $generated@@490) $generated@@491 $generated@@492)) +(assert (forall (($generated@@410 T@U) ($generated@@411 T@U) ($generated@@412 T@U) ) (! (= ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) ($generated@@409 $generated@@410) $generated@@411 $generated@@412) $generated@@410) + :pattern ( ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 ($generated@@46 $generated@@42 $generated@@15) ($generated@@409 $generated@@410) $generated@@411 $generated@@412)) ))) -(assert (forall (($generated@@494 T@U) ($generated@@495 T@U) ($generated@@496 T@U) ) (! (= ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@42 ($generated@@493 $generated@@494) $generated@@495 $generated@@496) $generated@@494) - :pattern ( ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@42 ($generated@@493 $generated@@494) $generated@@495 $generated@@496)) +(assert (forall (($generated@@414 T@U) ($generated@@415 T@U) ($generated@@416 T@U) ) (! (= ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@42 ($generated@@413 $generated@@414) $generated@@415 $generated@@416) $generated@@414) + :pattern ( ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@42 ($generated@@413 $generated@@414) $generated@@415 $generated@@416)) ))) -(assert (forall (($generated@@498 T@U) ($generated@@499 Bool) ($generated@@500 T@U) ($generated@@501 T@U) ) (! (= ($generated@@19 ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@15 ($generated@@497 $generated@@498 $generated@@499) $generated@@500 $generated@@501)) (and ($generated@@44 $generated@@42 $generated@@501 $generated@@498) $generated@@499)) - :pattern ( ($generated@@197 ($generated@@46 $generated@@77 ($generated@@78 $generated@@42)) $generated@@42 $generated@@15 ($generated@@497 $generated@@498 $generated@@499) $generated@@500 $generated@@501)) +(assert (forall (($generated@@418 T@U) ($generated@@419 Bool) ($generated@@420 T@U) ($generated@@421 T@U) ) (! (= ($generated@@19 ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@15 ($generated@@417 $generated@@418 $generated@@419) $generated@@420 $generated@@421)) (and ($generated@@44 $generated@@421 $generated@@418) $generated@@419)) + :pattern ( ($generated@@174 ($generated@@46 $generated@@91 ($generated@@46 $generated@@95 $generated@@42)) $generated@@42 $generated@@15 ($generated@@417 $generated@@418 $generated@@419) $generated@@420 $generated@@421)) ))) (push 1) (declare-fun ControlFlow (Int Int) Int) -(declare-fun $generated@@502 () T@U) -(declare-fun $generated@@503 () T@U) -(declare-fun $generated@@504 () T@U) -(declare-fun $generated@@505 () T@U) -(declare-fun $generated@@506 () T@U) -(declare-fun $generated@@507 () T@U) -(declare-fun $generated@@508 () T@U) -(declare-fun $generated@@509 () T@U) -(declare-fun $generated@@510 () T@U) -(declare-fun $generated@@511 (T@U) Bool) -(declare-fun $generated@@512 () T@U) +(declare-fun $generated@@422 () T@U) +(declare-fun $generated@@423 () T@U) +(declare-fun $generated@@424 () T@U) +(declare-fun $generated@@425 () T@U) +(declare-fun $generated@@426 () T@U) +(declare-fun $generated@@427 () T@U) +(declare-fun $generated@@428 () T@U) +(declare-fun $generated@@429 () T@U) +(declare-fun $generated@@430 () T@U) +(declare-fun $generated@@431 (T@U) Bool) +(declare-fun $generated@@432 () T@U) (set-option :timeout 0) (set-option :rlimit 0) (set-option :auto_config false) @@ -1955,19 +1895,19 @@ $generated@@337))))))))) (set-option :pp.bv_literals false) (set-option :smt.arith.solver 2) (assert (not - (=> (= (ControlFlow 0 0) 14) (let (($generated@@513 true)) -(let (($generated@@514 (=> (and (= ($generated@@32 $generated@@33 $generated@@116) $generated@@116) (= (ControlFlow 0 8) (- 0 7))) false))) -(let (($generated@@515 (=> ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false))) (and (=> (= (ControlFlow 0 10) 8) $generated@@514) (=> (= (ControlFlow 0 10) 9) $generated@@513))))) -(let (($generated@@516 true)) -(let (($generated@@517 (=> (and (not ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) (= (ControlFlow 0 6) 4)) $generated@@516))) -(let (($generated@@518 (=> (and (and ($generated@@44 $generated@@42 $generated@@502 $generated@@503) ($generated@@172 $generated@@42 $generated@@502 $generated@@503 $generated@@504)) (= $generated@@505 ($generated@@365 $generated@@109 $generated@@504 $generated@@1 false))) (and (=> (= (ControlFlow 0 11) 10) $generated@@515) (=> (= (ControlFlow 0 11) 6) $generated@@517))))) -(let (($generated@@519 (=> (and (not (and ($generated@@44 $generated@@42 $generated@@502 $generated@@503) ($generated@@172 $generated@@42 $generated@@502 $generated@@503 $generated@@504))) (= (ControlFlow 0 5) 4)) $generated@@516))) -(let (($generated@@520 (=> (and ($generated@@34 $generated@@504) (or (= $generated@@506 $generated@@504) ($generated@@74 $generated@@506 $generated@@504))) (and (=> (= (ControlFlow 0 12) 11) $generated@@518) (=> (= (ControlFlow 0 12) 5) $generated@@519))))) -(let (($generated@@521 (=> (and (and ($generated@@35 $generated@@503 $generated@@507 ($generated@@32 $generated@@33 ($generated@@150 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@423 $generated@@42)) ($generated@@32 $generated@@47 ($generated@@162 $generated@@47 ($generated@@247 ($generated@@196 ($generated@@493 $generated@@508) ($generated@@497 $generated@@503 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@489 ($generated@@159 ($generated@@244 false))))) ($generated@@408 $generated@@509)))))) (= (ControlFlow 0 3) (- 0 2))) ($generated@@35 $generated@@503 $generated@@507 ($generated@@32 $generated@@33 ($generated@@150 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@423 $generated@@42)) ($generated@@32 $generated@@47 ($generated@@162 $generated@@47 ($generated@@247 ($generated@@196 ($generated@@493 $generated@@508) ($generated@@497 $generated@@503 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@489 ($generated@@159 ($generated@@244 false))))) ($generated@@408 $generated@@509))))))) ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 ($generated@@31 $generated@@503 $generated@@507 ($generated@@32 $generated@@33 ($generated@@150 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) ($generated@@423 $generated@@42)) ($generated@@32 $generated@@47 ($generated@@162 $generated@@47 ($generated@@247 ($generated@@196 ($generated@@493 $generated@@508) ($generated@@497 $generated@@503 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@489 ($generated@@159 ($generated@@244 false))))) ($generated@@408 $generated@@509)))))))))))) -(let (($generated@@522 true)) -(let (($generated@@523 (=> (= $generated@@510 ($generated@@319 $generated@@109 $generated@@506 $generated@@1 false)) (and (and (=> (= (ControlFlow 0 13) 1) $generated@@522) (=> (= (ControlFlow 0 13) 12) $generated@@520)) (=> (= (ControlFlow 0 13) 3) $generated@@521))))) -(let (($generated@@524 (=> (and (and (and ($generated@@34 $generated@@506) ($generated@@511 $generated@@506)) ($generated@@36 $generated@@33 $generated@@512 ($generated@@37 $generated@@503 $generated@@507))) (and (= 1 $generated@@30) (= (ControlFlow 0 14) 13))) $generated@@523))) -$generated@@524))))))))))))) + (=> (= (ControlFlow 0 0) 14) (let (($generated@@433 true)) +(let (($generated@@434 (=> (and (= ($generated@@32 $generated@@33 $generated@@81) $generated@@81) (= (ControlFlow 0 8) (- 0 7))) false))) +(let (($generated@@435 (=> ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false))) (and (=> (= (ControlFlow 0 10) 8) $generated@@434) (=> (= (ControlFlow 0 10) 9) $generated@@433))))) +(let (($generated@@436 true)) +(let (($generated@@437 (=> (and (not ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) (= (ControlFlow 0 6) 4)) $generated@@436))) +(let (($generated@@438 (=> (and (and ($generated@@44 $generated@@422 $generated@@423) ($generated@@151 $generated@@422 $generated@@423 $generated@@424)) (= $generated@@425 ($generated@@327 $generated@@93 $generated@@424 $generated@@1 false))) (and (=> (= (ControlFlow 0 11) 10) $generated@@435) (=> (= (ControlFlow 0 11) 6) $generated@@437))))) +(let (($generated@@439 (=> (and (not (and ($generated@@44 $generated@@422 $generated@@423) ($generated@@151 $generated@@422 $generated@@423 $generated@@424))) (= (ControlFlow 0 5) 4)) $generated@@436))) +(let (($generated@@440 (=> (and ($generated@@34 $generated@@424) (or (= $generated@@426 $generated@@424) ($generated@@103 $generated@@426 $generated@@424))) (and (=> (= (ControlFlow 0 12) 11) $generated@@438) (=> (= (ControlFlow 0 12) 5) $generated@@439))))) +(let (($generated@@441 (=> (and (and ($generated@@35 $generated@@423 $generated@@427 ($generated@@32 $generated@@33 ($generated@@126 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@325) ($generated@@32 $generated@@47 ($generated@@141 $generated@@47 ($generated@@218 ($generated@@173 ($generated@@413 $generated@@428) ($generated@@417 $generated@@423 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@409 ($generated@@138 ($generated@@215 false))))) ($generated@@311 $generated@@429)))))) (= (ControlFlow 0 3) (- 0 2))) ($generated@@35 $generated@@423 $generated@@427 ($generated@@32 $generated@@33 ($generated@@126 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@325) ($generated@@32 $generated@@47 ($generated@@141 $generated@@47 ($generated@@218 ($generated@@173 ($generated@@413 $generated@@428) ($generated@@417 $generated@@423 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@409 ($generated@@138 ($generated@@215 false))))) ($generated@@311 $generated@@429))))))) ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 ($generated@@31 $generated@@423 $generated@@427 ($generated@@32 $generated@@33 ($generated@@126 ($generated@@32 ($generated@@46 $generated@@42 $generated@@15) $generated@@325) ($generated@@32 $generated@@47 ($generated@@141 $generated@@47 ($generated@@218 ($generated@@173 ($generated@@413 $generated@@428) ($generated@@417 $generated@@423 ($generated@@19 ($generated@@32 $generated@@15 ($generated@@18 false)))) ($generated@@409 ($generated@@138 ($generated@@215 false))))) ($generated@@311 $generated@@429)))))))))))) +(let (($generated@@442 true)) +(let (($generated@@443 (=> (= $generated@@430 ($generated@@327 $generated@@93 $generated@@426 $generated@@1 false)) (and (and (=> (= (ControlFlow 0 13) 1) $generated@@442) (=> (= (ControlFlow 0 13) 12) $generated@@440)) (=> (= (ControlFlow 0 13) 3) $generated@@441))))) +(let (($generated@@444 (=> (and (and (and ($generated@@34 $generated@@426) ($generated@@431 $generated@@426)) ($generated@@36 $generated@@33 $generated@@432 ($generated@@37 $generated@@423 $generated@@427))) (and (= 1 $generated@@30) (= (ControlFlow 0 14) 13))) $generated@@443))) +$generated@@444))))))))))))) )) (check-sat) (get-info :rlimit) diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-cs.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-cs.doo index 1eff2b016db95aeb9b317b2f922c3580956a619a..cb9be909cf6269994e55bb7fe952c21fe1f68ffa 100644 GIT binary patch delta 44 ucmdnPwTFv0z?+#xgn@y9gW*w!-9+9C%s^`6gGbCDdh$^g3lKet)dm1GJ`YR) delta 44 ucmdnPwTFv0z?+#xgn@y9gJGhp$wb}@%s^`6gGbCDdh$^g3lKet)dm0w$PCl~ diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-go.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-go.doo index 92b8cb8b93dfa4e3be0c00e37d4cfae488799516..aba548334293b944064d7c44eecd81ebdd22d07f 100644 GIT binary patch delta 45 ucmcb>b%BdFz?+#xgn@y9gW*|+-9+9C%s^`6gKx|rdh$&c3otFhY6AdG*$=@0 delta 45 ucmcb>b%BdFz?+#xgn@y9gJG(x$wb}@%s^`6gKx|rdh$&c3otFhY6Acu>kUZ& diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-java.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-java.doo index 4ae511b9881cf35433d8a1d62c5d7dbe86c9e514..4f907bb62d278594a78d3c8e8d85810122ad0feb 100644 GIT binary patch delta 45 ucmZ3J$Pcmr delta 45 ucmX@jcbbnkz?+#xgn@y9gJFuR$wb}@%s^`6gO98rdh!)E3oy;kZUX=x+6_7Y diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-notarget.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-notarget.doo index d5304e865885089b78512f21e979bf42124a65d4..87a7847c41b19484425775ea9e347d6ab6f7b61e 100644 GIT binary patch delta 45 ucmZ3)wTO#1z?+#xgn@y9gW*Ak-9+9C%s^`6gA>dkdh%)(3o!kR#RdR5g%832 delta 45 ucmZ3)wTO#1z?+#xgn@y9gJFWJ$wb}@%s^`6gA>dkdh%)(3o!kR#RdQj;tfs! diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-py.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries-py.doo index 377fb4e26e5cc78550f5d10dd4a50a2235c2aa9a..cb68004416584fe64551379f987a826b8fb57723 100644 GIT binary patch delta 45 ucmdnYwV8`Iz?+#xgn@y9gW*Mo-9+9C%s^`6gPY7Cdh#9?3o!ki#RdRF)etuT delta 45 ucmdnYwV8`Iz?+#xgn@y9gJHU>$wb}@%s^`6gPY7Cdh#9?3o!ki#RdQt=MBFA diff --git a/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries.doo b/Source/DafnyStandardLibraries/binaries/DafnyStandardLibraries.doo index 9903fdd37d31085240ef17fa3ac562144b223bb5..ef3c8d84efd3f32a8a6c5bc3dfb280dcd2837666 100644 GIT binary patch delta 55133 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 delta 55100 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 F003XlMo0hv diff --git a/Source/DafnyStandardLibraries/src/Std/Arithmetic/Internal/ModInternals.dfy b/Source/DafnyStandardLibraries/src/Std/Arithmetic/Internal/ModInternals.dfy index 4fdd5b9a22..452347eb3b 100644 --- a/Source/DafnyStandardLibraries/src/Std/Arithmetic/Internal/ModInternals.dfy +++ b/Source/DafnyStandardLibraries/src/Std/Arithmetic/Internal/ModInternals.dfy @@ -76,52 +76,84 @@ module {:disableNonlinearArithmetic} Std.Arithmetic.ModInternals { } } - lemma LemmaDivAddDenominator(n: int, x: int) + lemma {:vcs_split_on_every_assert} LemmaDivAddDenominator(n: int, x: int) requires n > 0 ensures (x + n) / n == x / n + 1 { LemmaFundamentalDivMod(x, n); LemmaFundamentalDivMod(x + n, n); var zp := (x + n) / n - x / n - 1; - assert 0 == n * zp + ((x + n) % n) - (x % n) by { LemmaMulAuto(); } - if (zp > 0) { LemmaMulInequality(1, zp, n); } - if (zp < 0) { LemmaMulInequality(zp, -1, n); } + assert 0 == n * zp + ((x + n) % n) - (x % n) by { LemmaMulDistributes(); } + if (zp > 0) { + assert (x + n) / n == x / n + 1 by { + LemmaMulInequality(1, zp, n); + } + } + if (zp < 0) { + assert (x + n) / n == x / n + 1 by { + LemmaMulInequality(zp, -1, n); + } + } } - lemma LemmaDivSubDenominator(n: int, x: int) + lemma {:vcs_split_on_every_assert} LemmaDivSubDenominator(n: int, x: int) requires n > 0 ensures (x - n) / n == x / n - 1 { LemmaFundamentalDivMod(x, n); LemmaFundamentalDivMod(x - n, n); var zm := (x - n) / n - x / n + 1; - assert 0 == n * zm + ((x - n) % n) - (x % n) by { LemmaMulAuto(); } - if (zm > 0) { LemmaMulInequality(1, zm, n); } - if (zm < 0) { LemmaMulInequality(zm, -1, n); } + assert 0 == n * zm + ((x - n) % n) - (x % n) by { LemmaMulDistributes(); } + if (zm > 0) { + assert (x - n) / n == x / n - 1 by { + LemmaMulInequality(1, zm, n); + } + } + if (zm < 0) { + assert (x - n) / n == x / n - 1 by { + LemmaMulInequality(zm, -1, n); + } + } } - lemma LemmaModAddDenominator(n: int, x: int) + lemma {:vcs_split_on_every_assert} LemmaModAddDenominator(n: int, x: int) requires n > 0 ensures (x + n) % n == x % n { LemmaFundamentalDivMod(x, n); LemmaFundamentalDivMod(x + n, n); var zp := (x + n) / n - x / n - 1; - assert 0 == n * zp + ((x + n) % n) - (x % n) by { LemmaMulAuto(); } - if (zp > 0) { LemmaMulInequality(1, zp, n); } - if (zp < 0) { LemmaMulInequality(zp, -1, n); } + assert 0 == n * zp + ((x + n) % n) - (x % n) by { LemmaMulDistributes(); } + if (zp > 0) { + assert (x + n) % n == x % n by { + LemmaMulInequality(1, zp, n); + } + } + if (zp < 0) { + assert (x + n) % n == x % n by { + LemmaMulInequality(zp, -1, n); + } + } } - lemma LemmaModSubDenominator(n: int, x: int) + lemma {:vcs_split_on_every_assert} LemmaModSubDenominator(n: int, x: int) requires n > 0 ensures (x - n) % n == x % n { LemmaFundamentalDivMod(x, n); LemmaFundamentalDivMod(x - n, n); var zm := (x - n) / n - x / n + 1; - assert 0 == n * zm + ((x - n) % n) - (x % n) by { LemmaMulAuto(); } - if (zm > 0) { LemmaMulInequality(1, zm, n); } - if (zm < 0) { LemmaMulInequality(zm, -1, n); } + assert 0 == n * zm + ((x - n) % n) - (x % n) by { LemmaMulDistributes(); } + if (zm > 0) { + assert (x - n) % n == x % n by { + LemmaMulInequality(1, zm, n); + } + } + if (zm < 0) { + assert (x - n) % n == x % n by { + LemmaMulInequality(zm, -1, n); + } + } } lemma LemmaModBelowDenominator(n: int, x: int) diff --git a/Source/DafnyStandardLibraries/src/Std/Arithmetic/LittleEndianNat.dfy b/Source/DafnyStandardLibraries/src/Std/Arithmetic/LittleEndianNat.dfy index 865b8b3b4c..55ee9d2bf9 100644 --- a/Source/DafnyStandardLibraries/src/Std/Arithmetic/LittleEndianNat.dfy +++ b/Source/DafnyStandardLibraries/src/Std/Arithmetic/LittleEndianNat.dfy @@ -228,7 +228,7 @@ abstract module {:disableNonlinearArithmetic} Std.Arithmetic.LittleEndianNat { /* Two sequences do not have the same nat representations if their prefixes do not have the same nat representations. Helper lemma for LemmaSeqNeq. */ - lemma LemmaSeqPrefixNeq(xs: seq, ys: seq, i: nat) + lemma {:vcs_split_on_every_assert} LemmaSeqPrefixNeq(xs: seq, ys: seq, i: nat) requires 0 <= i <= |xs| == |ys| requires ToNatRight(xs[..i]) != ToNatRight(ys[..i]) ensures ToNatRight(xs) != ToNatRight(ys) @@ -452,7 +452,7 @@ abstract module {:disableNonlinearArithmetic} Std.Arithmetic.LittleEndianNat { /* If the nat representation of a sequence is zero, then the sequence is a sequence of zeros. */ - lemma LemmaSeqZero(xs: seq) + lemma {:resource_limit "10e6"} LemmaSeqZero(xs: seq) requires ToNatRight(xs) == 0 ensures forall i :: 0 <= i < |xs| ==> xs[i] == 0 { diff --git a/Source/DafnyStandardLibraries/src/Std/JSON/ZeroCopy/Deserializer.dfy b/Source/DafnyStandardLibraries/src/Std/JSON/ZeroCopy/Deserializer.dfy index 4e8e21814f..2d1bb74033 100644 --- a/Source/DafnyStandardLibraries/src/Std/JSON/ZeroCopy/Deserializer.dfy +++ b/Source/DafnyStandardLibraries/src/Std/JSON/ZeroCopy/Deserializer.dfy @@ -280,7 +280,7 @@ module Std.JSON.ZeroCopy.Deserializer { elems' } - lemma {:resource_limit 10000000} AboutTryStructural(cs: FreshCursor) + lemma {:resource_limit "10e6"} {:vcs_split_on_every_assert} AboutTryStructural(cs: FreshCursor) ensures var sp := Core.TryStructural(cs); var s0 := sp.t.t.Peek(); diff --git a/Source/DafnyStandardLibraries/src/Std/Unicode/Utf8EncodingScheme.dfy b/Source/DafnyStandardLibraries/src/Std/Unicode/Utf8EncodingScheme.dfy index 5aa4a6a3a1..6ba5421dd3 100644 --- a/Source/DafnyStandardLibraries/src/Std/Unicode/Utf8EncodingScheme.dfy +++ b/Source/DafnyStandardLibraries/src/Std/Unicode/Utf8EncodingScheme.dfy @@ -54,7 +54,7 @@ module Std.Unicode.Utf8EncodingScheme { * Deserializing a byte sequence and then serializing the result, yields the original byte sequence. */ lemma - {:resource_limit 3000000} + {:resource_limit "30e6"} LemmaDeserializeSerialize(b: seq) ensures Serialize(Deserialize(b)) == b { diff --git a/Source/DafnyTestGeneration/ProgramModifier.cs b/Source/DafnyTestGeneration/ProgramModifier.cs index 0fb8e71028..a1bb9839e6 100644 --- a/Source/DafnyTestGeneration/ProgramModifier.cs +++ b/Source/DafnyTestGeneration/ProgramModifier.cs @@ -87,8 +87,8 @@ private static void AddAxioms(DafnyOptions options, Program program) { if (options.TestGenOptions.SeqLengthLimit == 0) { return; } - var limit = options.TestGenOptions.SeqLengthLimit; - Parser.Parse($"axiom (forall y: Seq T :: " + + var limit = (uint)options.TestGenOptions.SeqLengthLimit; + Parser.Parse($"axiom (forall y: Seq :: " + $"{{ Seq#Length(y) }} Seq#Length(y) <= {limit});", "", out var tmpProgram); program.AddTopLevelDeclaration( diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/12-MutexLifetime-short.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/12-MutexLifetime-short.dfy index d622cc5377..29fe1f7a82 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/12-MutexLifetime-short.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/concurrency/12-MutexLifetime-short.dfy @@ -846,7 +846,7 @@ class MutexGuardU32 extends OwnedObject { ghost predicate volatileOwns() { false } ghost function objectUserFields(): set reads this { - { mutex, data } + { mutex as Object, data as Object } } twostate predicate unchangedNonvolatileUserFields() reads this { diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy index a3314aced9..3f5c0d82f1 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy @@ -113,8 +113,13 @@ class Concurrent { b.x := 42; } - ghost method {:concurrent} AllTheBoxes() + ghost method {:concurrent} ReadAllTheBoxes() reads set b: GhostBox | true // Error: reads clause could not be proved to be empty ({:concurrent} restriction) + { + } + + ghost method {:concurrent} ModifyAllTheBoxes() + reads {} modifies set b: GhostBox | true // Error: modifies clause could not be proved to be empty ({:concurrent} restriction) { } diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy.expect index b3ad582b88..b2ec5da839 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ConcurrentAttribute.dfy.expect @@ -1,7 +1,7 @@ ConcurrentAttribute.dfy(117,10): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. -ConcurrentAttribute.dfy(118,13): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. -ConcurrentAttribute.dfy(123,10): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. -ConcurrentAttribute.dfy(124,13): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. +ConcurrentAttribute.dfy(123,13): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. +ConcurrentAttribute.dfy(128,10): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. +ConcurrentAttribute.dfy(129,13): Warning: Could not find a trigger for this quantifier. Without a trigger, the quantifier may cause brittle verification. To silence this warning, add an explicit trigger using the {:trigger} attribute. For more information, see the section quantifier instantiation rules in the reference manual. ConcurrentAttribute.dfy(49,25): Error: reads clause could not be proved to be empty ({:concurrent} restriction) ConcurrentAttribute.dfy(67,32): Error: reads clause could not be proved to be empty ({:concurrent} restriction) ConcurrentAttribute.dfy(74,23): Error: reads clause could not be proved to be empty ({:concurrent} restriction) @@ -12,6 +12,6 @@ ConcurrentAttribute.dfy(98,23): Error: reads clause could not be proved to be em ConcurrentAttribute.dfy(103,29): Error: reads clause could not be proved to be empty ({:concurrent} restriction) ConcurrentAttribute.dfy(109,23): Error: modifies clause could not be proved to be empty ({:concurrent} restriction) ConcurrentAttribute.dfy(116,29): Error: reads clause could not be proved to be empty ({:concurrent} restriction) -ConcurrentAttribute.dfy(116,29): Error: modifies clause could not be proved to be empty ({:concurrent} restriction) +ConcurrentAttribute.dfy(121,29): Error: modifies clause could not be proved to be empty ({:concurrent} restriction) Dafny program verifier finished with 15 verified, 11 errors diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy.dfy.expect index 9c3bc1382a..0844ff7edf 100755 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/Fuel.legacy.dfy.expect @@ -21,19 +21,19 @@ Fuel.legacy.dfy(324,21): Related location Fuel.legacy.dfy(313,41): Related location Fuel.legacy.dfy(335,26): Error: function precondition could not be proved Fuel.legacy.dfy(324,21): Related location -Fuel.legacy.dfy(314,72): Related location +Fuel.legacy.dfy(312,43): Related location Fuel.legacy.dfy(335,26): Error: function precondition could not be proved Fuel.legacy.dfy(324,21): Related location -Fuel.legacy.dfy(314,93): Related location +Fuel.legacy.dfy(312,58): Related location Fuel.legacy.dfy(335,26): Error: function precondition could not be proved Fuel.legacy.dfy(324,21): Related location -Fuel.legacy.dfy(312,43): Related location +Fuel.legacy.dfy(314,46): Related location Fuel.legacy.dfy(335,26): Error: function precondition could not be proved Fuel.legacy.dfy(324,21): Related location -Fuel.legacy.dfy(312,58): Related location +Fuel.legacy.dfy(314,72): Related location Fuel.legacy.dfy(335,26): Error: function precondition could not be proved Fuel.legacy.dfy(324,21): Related location -Fuel.legacy.dfy(314,46): Related location +Fuel.legacy.dfy(314,93): Related location Fuel.legacy.dfy(335,49): Error: destructor 't' can only be applied to datatype values constructed by 'VTuple' Fuel.legacy.dfy(335,50): Error: index out of range Fuel.legacy.dfy(336,38): Error: index out of range @@ -43,16 +43,16 @@ Fuel.legacy.dfy(329,21): Related location Fuel.legacy.dfy(311,43): Related location Fuel.legacy.dfy(336,45): Error: function precondition could not be proved Fuel.legacy.dfy(329,21): Related location -Fuel.legacy.dfy(313,41): Related location +Fuel.legacy.dfy(314,72): Related location Fuel.legacy.dfy(336,45): Error: function precondition could not be proved Fuel.legacy.dfy(329,21): Related location -Fuel.legacy.dfy(312,58): Related location +Fuel.legacy.dfy(314,93): Related location Fuel.legacy.dfy(336,45): Error: function precondition could not be proved Fuel.legacy.dfy(329,21): Related location -Fuel.legacy.dfy(314,72): Related location +Fuel.legacy.dfy(312,58): Related location Fuel.legacy.dfy(336,45): Error: function precondition could not be proved Fuel.legacy.dfy(329,21): Related location -Fuel.legacy.dfy(314,93): Related location +Fuel.legacy.dfy(313,41): Related location Fuel.legacy.dfy(336,45): Error: function precondition could not be proved Fuel.legacy.dfy(329,21): Related location Fuel.legacy.dfy(312,43): Related location diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ReadsOnMethods.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ReadsOnMethods.dfy.expect index 3647f28b04..cde33603b3 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ReadsOnMethods.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/ReadsOnMethods.dfy.expect @@ -16,7 +16,6 @@ ReadsOnMethods.dfy(183,25): Error: insufficient reads clause to read field ReadsOnMethods.dfy(245,9): Error: insufficient reads clause to read field ReadsOnMethods.dfy(304,33): Error: insufficient reads clause to read field ReadsOnMethods.dfy(308,22): Error: insufficient reads clause to invoke function -ReadsOnMethods.dfy(313,13): Error: call might violate context's modifies clause ReadsOnMethods.dfy(313,13): Error: insufficient reads clause to call ReadsOnMethods.dfy(360,20): Error: insufficient reads clause to call ReadsOnMethods.dfy(402,23): Error: insufficient reads clause to read field @@ -34,4 +33,4 @@ ReadsOnMethods.dfy(516,11): Related location ReadsOnMethods.dfy(523,13): Error: insufficient reads clause to read field ReadsOnMethods.dfy(530,50): Error: insufficient reads clause to read field -Dafny program verifier finished with 67 verified, 32 errors +Dafny program verifier finished with 67 verified, 31 errors diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/snapshots/Snapshots0.run.legacy.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/snapshots/Snapshots0.run.legacy.dfy.expect index 89bdd3ae0b..e1e675464d 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/snapshots/Snapshots0.run.legacy.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny0/snapshots/Snapshots0.run.legacy.dfy.expect @@ -3,7 +3,7 @@ Processing command (at Snapshots0.v0.dfy(4,10)) assert {:id "id1"} Lit(false); Dafny program verifier finished with 1 verified, 0 errors Processing call to procedure bar (call) in implementation foo (correctness) (at Snapshots0.v1.dfy(3,6)): - >>> added axiom: (forall call0old#AT#$Heap: Heap, $Heap: Heap :: {:weight 30} { ##extracted_function##1(call0old#AT#$Heap, $Heap) } ##extracted_function##1(call0old#AT#$Heap, $Heap) == (true && Lit(false) && (forall $o: ref :: { $Heap[$o] } $o != null && read(call0old#AT#$Heap, $o, alloc): bool ==> $Heap[$o] == call0old#AT#$Heap[$o]) && $HeapSucc(call0old#AT#$Heap, $Heap))) + >>> added axiom: (forall call0old#AT#$Heap: Heap, $Heap: Heap :: {:weight 30} { ##extracted_function##1(call0old#AT#$Heap, $Heap) } ##extracted_function##1(call0old#AT#$Heap, $Heap) == (true && Lit(false) && (forall $o: ref :: { $Heap[$o] } $o != null && $Unbox(read(call0old#AT#$Heap, $o, alloc)): bool ==> $Heap[$o] == call0old#AT#$Heap[$o]) && $HeapSucc(call0old#AT#$Heap, $Heap))) >>> added after: a##cached##0 := a##cached##0 && ##extracted_function##1(call0old#AT#$Heap, $Heap); Processing command (at ) a##cached##0 := a##cached##0 && ##extracted_function##1(call0old#AT#$Heap, $Heap); >>> AssumeNegationOfAssumptionVariable diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/pq-intrinsic-extrinsic.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/pq-intrinsic-extrinsic.dfy index 6d6df4538e..6cf5507c47 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/pq-intrinsic-extrinsic.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny2/pq-intrinsic-extrinsic.dfy @@ -219,7 +219,7 @@ module PriorityQueue_extrinsic { else Node(t.val, Insert(t.right, x), t.left) } - lemma AboutInsert(t: T, x: int) + lemma {:resource_limit "70e6"} AboutInsert(t: T, x: int) requires Valid(t) ensures var t' := Insert(t, x); Valid(t') && diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/FlyingRobots.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/FlyingRobots.dfy index 54980b680b..55eb5478ce 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/FlyingRobots.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/FlyingRobots.dfy @@ -212,7 +212,7 @@ method FlyRobotArmy(bots:seq) } } -method FlyRobotArmy_Recursively(bots:seq) +method {:resource_limit "100e6"} FlyRobotArmy_Recursively(bots:seq) requires ValidArmy(bots) modifies ArmyRepr(bots) ensures ValidArmy(bots) diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/Lucas-up.legacy.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/Lucas-up.legacy.dfy index c2002adf6b..38413c3be0 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/Lucas-up.legacy.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/Lucas-up.legacy.dfy @@ -66,7 +66,7 @@ ghost function binom(a: nat, b: nat): nat // div-2 is applied to both arguments, except in the case where // the first argument to "binom" is even and the second argument // is odd, in which case "binom" is always even. -lemma Lucas_Binary(a: nat, b: nat) +lemma {:resource_limit "8e6"} Lucas_Binary(a: nat, b: nat) ensures EVEN(binom(2*a, 2*b + 1)) ensures EVEN(binom(2*a, 2*b)) <==> EVEN(binom(a, b)) ensures EVEN(binom(2*a + 1, 2*b + 1)) <==> EVEN(binom(a, b)) @@ -83,7 +83,7 @@ lemma Lucas_Binary(a: nat, b: nat) } // Here is an alternative way to phrase the previous lemma. -lemma Lucas_Binary'(a: nat, b: nat) +lemma {:resource_limit "200e6"} Lucas_Binary'(a: nat, b: nat) ensures binom(2*a, 2*b) % 2 == binom(a, b) % 2 ensures binom(2*a, 2*b + 1) % 2 == 0 ensures binom(2*a + 1, 2*b) % 2 == binom(a, b) % 2 diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/UnionFind.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/UnionFind.dfy index 88b8134708..d80ac5cac0 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/UnionFind.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/dafny4/UnionFind.dfy @@ -65,7 +65,7 @@ abstract module M1 refines M0 { reads this, set a: Element | a in M ensures GoodCMap(Collect()) { - map e | e in M :: e.c + map e : Element | e in M :: e.c } ghost predicate {:autocontracts false} Reaches(d: nat, e: Element, r: Element, C: CMap) requires GoodCMap(C) diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2026.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2026.dfy.expect index 191893e6a7..a35b70826c 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2026.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/git-issue-2026.dfy.expect @@ -8,25 +8,29 @@ git-issue-2026.dfy(12,0): initial state: ret : _System.array> = () git-issue-2026.dfy(13,24): n : int = 2 - ret : _System.array?> = (Length := 2, [(- 7720)] := @0, [0] := @0) - @0 : seq = ['o', 'd', 'd'] + ret : _System.array?> = (Length := 2, [(- 1)] := @0, [0] := @1) + @0 : seq = ['e', 'v', 'e', 'n'] + @1 : seq = ['o', 'd', 'd'] git-issue-2026.dfy(15,14): n : int = 2 - ret : _System.array?> = (Length := 2, [(- 7720)] := @0, [0] := @0) + ret : _System.array?> = (Length := 2, [(- 1)] := @0, [0] := @1) i : int = 0 - @0 : seq = ['o', 'd', 'd'] + @0 : seq = ['e', 'v', 'e', 'n'] + @1 : seq = ['o', 'd', 'd'] git-issue-2026.dfy(16,4): after some loop iterations: n : int = 2 - ret : _System.array?> = (Length := 2, [(- 7720)] := @0) + ret : _System.array?> = (Length := 2, [(- 1)] := @0) i : int = 0 - @0 : seq = ['o', 'd', 'd'] + @0 : seq = ['e', 'v', 'e', 'n'] git-issue-2026.dfy(22,27): n : int = 2 - ret : _System.array?> = (Length := 2, [(- 7720)] := @0, [0] := @0) + ret : _System.array?> = (Length := 2, [(- 1)] := @0, [0] := @1) i : int = 0 - @0 : seq = ['o', 'd', 'd'] + @0 : seq = ['e', 'v', 'e', 'n'] + @1 : seq = ['o', 'd', 'd'] git-issue-2026.dfy(26,18): n : int = 2 - ret : _System.array?> = (Length := 2, [(- 7720)] := @0, [0] := @0) + ret : _System.array?> = (Length := 2, [(- 1)] := @0, [0] := @1) i : int = 1 - @0 : seq = ['o', 'd', 'd'] + @0 : seq = ['e', 'v', 'e', 'n'] + @1 : seq = ['o', 'd', 'd'] diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy index d4b02ecb18..146cc90179 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy @@ -71,7 +71,11 @@ lemma UpCastRShiftMasking(v: bv64, idx: nat) ensures v as bv128 == (v as bv128) & (Ones >> idx) {} +// This one has worked in the past but is very brittle. Changing +// unrelated background axioms causes it to fail. +/* lemma RightMask(v: bv64, i: nat) requires 64 <= i <= 128 ensures v as bv128 & (Ones >> i) == (v & (0xffff_ffff_ffff_ffff >> i - 64)) as bv128 {} +*/ diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy.expect b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy.expect index 8c4d74ae00..9b96db8633 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy.expect +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/git-issues/github-issue-2174.dfy.expect @@ -1,2 +1,2 @@ -Dafny program verifier finished with 19 verified, 0 errors +Dafny program verifier finished with 17 verified, 0 errors diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/auto-triggers-fix-an-issue-listed-in-the-ironclad-notebook.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/auto-triggers-fix-an-issue-listed-in-the-ironclad-notebook.dfy index f09f6ce129..5aebbd908e 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/auto-triggers-fix-an-issue-listed-in-the-ironclad-notebook.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/auto-triggers-fix-an-issue-listed-in-the-ironclad-notebook.dfy @@ -4,7 +4,7 @@ // This example was listed in IronClad's notebook as one place were z3 picked // much too liberal triggers. THe Boogie code for this is shown below: // -// forall k#2: Seq Box :: $Is(k#2, TSeq(TInt)) && $IsAlloc(k#2, TSeq(TInt), $Heap) +// forall k#2: Seq :: $Is(k#2, TSeq(TInt)) && $IsAlloc(k#2, TSeq(TInt), $Heap) // ==> Seq#Equal(_module.__default.HashtableLookup($Heap, h1#0, k#2), // _module.__default.HashtableLookup($Heap, h2#0, k#2)) // diff --git a/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/set-construction-is-a-good-trigger.dfy b/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/set-construction-is-a-good-trigger.dfy index 084b10c674..f5e2ae392b 100644 --- a/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/set-construction-is-a-good-trigger.dfy +++ b/Source/IntegrationTests/TestFiles/LitTests/LitTest/triggers/set-construction-is-a-good-trigger.dfy @@ -5,7 +5,7 @@ // useful for code that checks if a set, sequence, or multiset is a singleton. method M(s: seq, st: set, mst: multiset) - requires exists y :: s == [y] // Seq#Build(Seq#Empty(): Seq Box, $Box(y#3)) + requires exists y :: s == [y] // Seq#Build(Seq#Empty(): Seq, $Box(y#3)) requires exists y :: st == {y} // Set#UnionOne(Set#Empty(): Set Box, $Box(y#4)) requires exists y :: mst == multiset{y} // MultiSet#UnionOne(MultiSet#Empty(): MultiSet Box, $Box(y#5)) {